@slicemachine/manager 0.1.1-dev-plugins.3

package/dist/__node_modules/graphql/index.cjs

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const version = require("./version.cjs");
+const graphql$1 = require("./graphql.cjs");
+const definition = require("./type/definition.cjs");
+const schema = require("./type/schema.cjs");
+const directives = require("./type/directives.cjs");
+const scalars = require("./type/scalars.cjs");
+const introspection = require("./type/introspection.cjs");
+const validate = require("./type/validate.cjs");
+const assertName = require("./type/assertName.cjs");
+const ast = require("./language/ast.cjs");
+const source = require("./language/source.cjs");
+const location = require("./language/location.cjs");
+const printLocation = require("./language/printLocation.cjs");
+const lexer = require("./language/lexer.cjs");
+const tokenKind = require("./language/tokenKind.cjs");
+const parser = require("./language/parser.cjs");
+const printer = require("./language/printer.cjs");
+const visitor = require("./language/visitor.cjs");
+const kinds = require("./language/kinds.cjs");
+const directiveLocation = require("./language/directiveLocation.cjs");
+const predicates = require("./language/predicates.cjs");
+const execute = require("./execution/execute.cjs");
+const Path = require("./jsutils/Path.cjs");
+const values = require("./execution/values.cjs");
+const subscribe = require("./execution/subscribe.cjs");
+const validate$1 = require("./validation/validate.cjs");
+const ValidationContext = require("./validation/ValidationContext.cjs");
+const specifiedRules = require("./validation/specifiedRules.cjs");
+const ExecutableDefinitionsRule = require("./validation/rules/ExecutableDefinitionsRule.cjs");
+const FieldsOnCorrectTypeRule = require("./validation/rules/FieldsOnCorrectTypeRule.cjs");
+const FragmentsOnCompositeTypesRule = require("./validation/rules/FragmentsOnCompositeTypesRule.cjs");
+const KnownArgumentNamesRule = require("./validation/rules/KnownArgumentNamesRule.cjs");
+const KnownDirectivesRule = require("./validation/rules/KnownDirectivesRule.cjs");
+const KnownFragmentNamesRule = require("./validation/rules/KnownFragmentNamesRule.cjs");
+const KnownTypeNamesRule = require("./validation/rules/KnownTypeNamesRule.cjs");
+const LoneAnonymousOperationRule = require("./validation/rules/LoneAnonymousOperationRule.cjs");
+const NoFragmentCyclesRule = require("./validation/rules/NoFragmentCyclesRule.cjs");
+const NoUndefinedVariablesRule = require("./validation/rules/NoUndefinedVariablesRule.cjs");
+const NoUnusedFragmentsRule = require("./validation/rules/NoUnusedFragmentsRule.cjs");
+const NoUnusedVariablesRule = require("./validation/rules/NoUnusedVariablesRule.cjs");
+const OverlappingFieldsCanBeMergedRule = require("./validation/rules/OverlappingFieldsCanBeMergedRule.cjs");
+const PossibleFragmentSpreadsRule = require("./validation/rules/PossibleFragmentSpreadsRule.cjs");
+const ProvidedRequiredArgumentsRule = require("./validation/rules/ProvidedRequiredArgumentsRule.cjs");
+const ScalarLeafsRule = require("./validation/rules/ScalarLeafsRule.cjs");
+const SingleFieldSubscriptionsRule = require("./validation/rules/SingleFieldSubscriptionsRule.cjs");
+const UniqueArgumentNamesRule = require("./validation/rules/UniqueArgumentNamesRule.cjs");
+const UniqueDirectivesPerLocationRule = require("./validation/rules/UniqueDirectivesPerLocationRule.cjs");
+const UniqueFragmentNamesRule = require("./validation/rules/UniqueFragmentNamesRule.cjs");
+const UniqueInputFieldNamesRule = require("./validation/rules/UniqueInputFieldNamesRule.cjs");
+const UniqueOperationNamesRule = require("./validation/rules/UniqueOperationNamesRule.cjs");
+const UniqueVariableNamesRule = require("./validation/rules/UniqueVariableNamesRule.cjs");
+const ValuesOfCorrectTypeRule = require("./validation/rules/ValuesOfCorrectTypeRule.cjs");
+const VariablesAreInputTypesRule = require("./validation/rules/VariablesAreInputTypesRule.cjs");
+const VariablesInAllowedPositionRule = require("./validation/rules/VariablesInAllowedPositionRule.cjs");
+const LoneSchemaDefinitionRule = require("./validation/rules/LoneSchemaDefinitionRule.cjs");
+const UniqueOperationTypesRule = require("./validation/rules/UniqueOperationTypesRule.cjs");
+const UniqueTypeNamesRule = require("./validation/rules/UniqueTypeNamesRule.cjs");
+const UniqueEnumValueNamesRule = require("./validation/rules/UniqueEnumValueNamesRule.cjs");
+const UniqueFieldDefinitionNamesRule = require("./validation/rules/UniqueFieldDefinitionNamesRule.cjs");
+const UniqueArgumentDefinitionNamesRule = require("./validation/rules/UniqueArgumentDefinitionNamesRule.cjs");
+const UniqueDirectiveNamesRule = require("./validation/rules/UniqueDirectiveNamesRule.cjs");
+const PossibleTypeExtensionsRule = require("./validation/rules/PossibleTypeExtensionsRule.cjs");
+const NoDeprecatedCustomRule = require("./validation/rules/custom/NoDeprecatedCustomRule.cjs");
+const NoSchemaIntrospectionCustomRule = require("./validation/rules/custom/NoSchemaIntrospectionCustomRule.cjs");
+const GraphQLError = require("./error/GraphQLError.cjs");
+const syntaxError = require("./error/syntaxError.cjs");
+const locatedError = require("./error/locatedError.cjs");
+const getIntrospectionQuery = require("./utilities/getIntrospectionQuery.cjs");
+const getOperationAST = require("./utilities/getOperationAST.cjs");
+const getOperationRootType = require("./utilities/getOperationRootType.cjs");
+const introspectionFromSchema = require("./utilities/introspectionFromSchema.cjs");
+const buildClientSchema = require("./utilities/buildClientSchema.cjs");
+const buildASTSchema = require("./utilities/buildASTSchema.cjs");
+const extendSchema = require("./utilities/extendSchema.cjs");
+const lexicographicSortSchema = require("./utilities/lexicographicSortSchema.cjs");
+const printSchema = require("./utilities/printSchema.cjs");
+const typeFromAST = require("./utilities/typeFromAST.cjs");
+const valueFromAST = require("./utilities/valueFromAST.cjs");
+const valueFromASTUntyped = require("./utilities/valueFromASTUntyped.cjs");
+const astFromValue = require("./utilities/astFromValue.cjs");
+const TypeInfo = require("./utilities/TypeInfo.cjs");
+const coerceInputValue = require("./utilities/coerceInputValue.cjs");
+const concatAST = require("./utilities/concatAST.cjs");
+const separateOperations = require("./utilities/separateOperations.cjs");
+const stripIgnoredCharacters = require("./utilities/stripIgnoredCharacters.cjs");
+const typeComparators = require("./utilities/typeComparators.cjs");
+const assertValidName = require("./utilities/assertValidName.cjs");
+const findBreakingChanges = require("./utilities/findBreakingChanges.cjs");
+exports.version = version.version;
+exports.versionInfo = version.versionInfo;
+exports.graphql = graphql$1.graphql;
+exports.graphqlSync = graphql$1.graphqlSync;
+exports.GraphQLEnumType = definition.GraphQLEnumType;
+exports.GraphQLInputObjectType = definition.GraphQLInputObjectType;
+exports.GraphQLInterfaceType = definition.GraphQLInterfaceType;
+exports.GraphQLList = definition.GraphQLList;
+exports.GraphQLNonNull = definition.GraphQLNonNull;
+exports.GraphQLObjectType = definition.GraphQLObjectType;
+exports.GraphQLScalarType = definition.GraphQLScalarType;
+exports.GraphQLUnionType = definition.GraphQLUnionType;
+exports.assertAbstractType = definition.assertAbstractType;
+exports.assertCompositeType = definition.assertCompositeType;
+exports.assertEnumType = definition.assertEnumType;
+exports.assertInputObjectType = definition.assertInputObjectType;
+exports.assertInputType = definition.assertInputType;
+exports.assertInterfaceType = definition.assertInterfaceType;
+exports.assertLeafType = definition.assertLeafType;
+exports.assertListType = definition.assertListType;
+exports.assertNamedType = definition.assertNamedType;
+exports.assertNonNullType = definition.assertNonNullType;
+exports.assertNullableType = definition.assertNullableType;
+exports.assertObjectType = definition.assertObjectType;
+exports.assertOutputType = definition.assertOutputType;
+exports.assertScalarType = definition.assertScalarType;
+exports.assertType = definition.assertType;
+exports.assertUnionType = definition.assertUnionType;
+exports.assertWrappingType = definition.assertWrappingType;
+exports.getNamedType = definition.getNamedType;
+exports.getNullableType = definition.getNullableType;
+exports.isAbstractType = definition.isAbstractType;
+exports.isCompositeType = definition.isCompositeType;
+exports.isEnumType = definition.isEnumType;
+exports.isInputObjectType = definition.isInputObjectType;
+exports.isInputType = definition.isInputType;
+exports.isInterfaceType = definition.isInterfaceType;
+exports.isLeafType = definition.isLeafType;
+exports.isListType = definition.isListType;
+exports.isNamedType = definition.isNamedType;
+exports.isNonNullType = definition.isNonNullType;
+exports.isNullableType = definition.isNullableType;
+exports.isObjectType = definition.isObjectType;
+exports.isOutputType = definition.isOutputType;
+exports.isRequiredArgument = definition.isRequiredArgument;
+exports.isRequiredInputField = definition.isRequiredInputField;
+exports.isScalarType = definition.isScalarType;
+exports.isType = definition.isType;
+exports.isUnionType = definition.isUnionType;
+exports.isWrappingType = definition.isWrappingType;
+exports.resolveObjMapThunk = definition.resolveObjMapThunk;
+exports.resolveReadonlyArrayThunk = definition.resolveReadonlyArrayThunk;
+exports.GraphQLSchema = schema.GraphQLSchema;
+exports.assertSchema = schema.assertSchema;
+exports.isSchema = schema.isSchema;
+exports.DEFAULT_DEPRECATION_REASON = directives.DEFAULT_DEPRECATION_REASON;
+exports.GraphQLDeprecatedDirective = directives.GraphQLDeprecatedDirective;
+exports.GraphQLDirective = directives.GraphQLDirective;
+exports.GraphQLIncludeDirective = directives.GraphQLIncludeDirective;
+exports.GraphQLSkipDirective = directives.GraphQLSkipDirective;
+exports.GraphQLSpecifiedByDirective = directives.GraphQLSpecifiedByDirective;
+exports.assertDirective = directives.assertDirective;
+exports.isDirective = directives.isDirective;
+exports.isSpecifiedDirective = directives.isSpecifiedDirective;
+exports.specifiedDirectives = directives.specifiedDirectives;
+exports.GRAPHQL_MAX_INT = scalars.GRAPHQL_MAX_INT;
+exports.GRAPHQL_MIN_INT = scalars.GRAPHQL_MIN_INT;
+exports.GraphQLBoolean = scalars.GraphQLBoolean;
+exports.GraphQLFloat = scalars.GraphQLFloat;
+exports.GraphQLID = scalars.GraphQLID;
+exports.GraphQLInt = scalars.GraphQLInt;
+exports.GraphQLString = scalars.GraphQLString;
+exports.isSpecifiedScalarType = scalars.isSpecifiedScalarType;
+exports.specifiedScalarTypes = scalars.specifiedScalarTypes;
+exports.SchemaMetaFieldDef = introspection.SchemaMetaFieldDef;
+Object.defineProperty(exports, "TypeKind", {
+  enumerable: true,
+  get: () => introspection.TypeKind
+});
+exports.TypeMetaFieldDef = introspection.TypeMetaFieldDef;
+exports.TypeNameMetaFieldDef = introspection.TypeNameMetaFieldDef;
+exports.__Directive = introspection.__Directive;
+exports.__DirectiveLocation = introspection.__DirectiveLocation;
+exports.__EnumValue = introspection.__EnumValue;
+exports.__Field = introspection.__Field;
+exports.__InputValue = introspection.__InputValue;
+exports.__Schema = introspection.__Schema;
+exports.__Type = introspection.__Type;
+exports.__TypeKind = introspection.__TypeKind;
+exports.introspectionTypes = introspection.introspectionTypes;
+exports.isIntrospectionType = introspection.isIntrospectionType;
+exports.assertValidSchema = validate.assertValidSchema;
+exports.validateSchema = validate.validateSchema;
+exports.assertEnumValueName = assertName.assertEnumValueName;
+exports.assertName = assertName.assertName;
+exports.Location = ast.Location;
+Object.defineProperty(exports, "OperationTypeNode", {
+  enumerable: true,
+  get: () => ast.OperationTypeNode
+});
+exports.Token = ast.Token;
+exports.Source = source.Source;
+exports.getLocation = location.getLocation;
+exports.printLocation = printLocation.printLocation;
+exports.printSourceLocation = printLocation.printSourceLocation;
+exports.Lexer = lexer.Lexer;
+Object.defineProperty(exports, "TokenKind", {
+  enumerable: true,
+  get: () => tokenKind.TokenKind
+});
+exports.parse = parser.parse;
+exports.parseConstValue = parser.parseConstValue;
+exports.parseType = parser.parseType;
+exports.parseValue = parser.parseValue;
+exports.print = printer.print;
+exports.BREAK = visitor.BREAK;
+exports.getEnterLeaveForKind = visitor.getEnterLeaveForKind;
+exports.getVisitFn = visitor.getVisitFn;
+exports.visit = visitor.visit;
+exports.visitInParallel = visitor.visitInParallel;
+Object.defineProperty(exports, "Kind", {
+  enumerable: true,
+  get: () => kinds.Kind
+});
+Object.defineProperty(exports, "DirectiveLocation", {
+  enumerable: true,
+  get: () => directiveLocation.DirectiveLocation
+});
+exports.isConstValueNode = predicates.isConstValueNode;
+exports.isDefinitionNode = predicates.isDefinitionNode;
+exports.isExecutableDefinitionNode = predicates.isExecutableDefinitionNode;
+exports.isSelectionNode = predicates.isSelectionNode;
+exports.isTypeDefinitionNode = predicates.isTypeDefinitionNode;
+exports.isTypeExtensionNode = predicates.isTypeExtensionNode;
+exports.isTypeNode = predicates.isTypeNode;
+exports.isTypeSystemDefinitionNode = predicates.isTypeSystemDefinitionNode;
+exports.isTypeSystemExtensionNode = predicates.isTypeSystemExtensionNode;
+exports.isValueNode = predicates.isValueNode;
+exports.defaultFieldResolver = execute.defaultFieldResolver;
+exports.defaultTypeResolver = execute.defaultTypeResolver;
+exports.execute = execute.execute;
+exports.executeSync = execute.executeSync;
+exports.responsePathAsArray = Path.pathToArray;
+exports.getArgumentValues = values.getArgumentValues;
+exports.getDirectiveValues = values.getDirectiveValues;
+exports.getVariableValues = values.getVariableValues;
+exports.createSourceEventStream = subscribe.createSourceEventStream;
+exports.subscribe = subscribe.subscribe;
+exports.validate = validate$1.validate;
+exports.ValidationContext = ValidationContext.ValidationContext;
+exports.specifiedRules = specifiedRules.specifiedRules;
+exports.ExecutableDefinitionsRule = ExecutableDefinitionsRule.ExecutableDefinitionsRule;
+exports.FieldsOnCorrectTypeRule = FieldsOnCorrectTypeRule.FieldsOnCorrectTypeRule;
+exports.FragmentsOnCompositeTypesRule = FragmentsOnCompositeTypesRule.FragmentsOnCompositeTypesRule;
+exports.KnownArgumentNamesRule = KnownArgumentNamesRule.KnownArgumentNamesRule;
+exports.KnownDirectivesRule = KnownDirectivesRule.KnownDirectivesRule;
+exports.KnownFragmentNamesRule = KnownFragmentNamesRule.KnownFragmentNamesRule;
+exports.KnownTypeNamesRule = KnownTypeNamesRule.KnownTypeNamesRule;
+exports.LoneAnonymousOperationRule = LoneAnonymousOperationRule.LoneAnonymousOperationRule;
+exports.NoFragmentCyclesRule = NoFragmentCyclesRule.NoFragmentCyclesRule;
+exports.NoUndefinedVariablesRule = NoUndefinedVariablesRule.NoUndefinedVariablesRule;
+exports.NoUnusedFragmentsRule = NoUnusedFragmentsRule.NoUnusedFragmentsRule;
+exports.NoUnusedVariablesRule = NoUnusedVariablesRule.NoUnusedVariablesRule;
+exports.OverlappingFieldsCanBeMergedRule = OverlappingFieldsCanBeMergedRule.OverlappingFieldsCanBeMergedRule;
+exports.PossibleFragmentSpreadsRule = PossibleFragmentSpreadsRule.PossibleFragmentSpreadsRule;
+exports.ProvidedRequiredArgumentsRule = ProvidedRequiredArgumentsRule.ProvidedRequiredArgumentsRule;
+exports.ScalarLeafsRule = ScalarLeafsRule.ScalarLeafsRule;
+exports.SingleFieldSubscriptionsRule = SingleFieldSubscriptionsRule.SingleFieldSubscriptionsRule;
+exports.UniqueArgumentNamesRule = UniqueArgumentNamesRule.UniqueArgumentNamesRule;
+exports.UniqueDirectivesPerLocationRule = UniqueDirectivesPerLocationRule.UniqueDirectivesPerLocationRule;
+exports.UniqueFragmentNamesRule = UniqueFragmentNamesRule.UniqueFragmentNamesRule;
+exports.UniqueInputFieldNamesRule = UniqueInputFieldNamesRule.UniqueInputFieldNamesRule;
+exports.UniqueOperationNamesRule = UniqueOperationNamesRule.UniqueOperationNamesRule;
+exports.UniqueVariableNamesRule = UniqueVariableNamesRule.UniqueVariableNamesRule;
+exports.ValuesOfCorrectTypeRule = ValuesOfCorrectTypeRule.ValuesOfCorrectTypeRule;
+exports.VariablesAreInputTypesRule = VariablesAreInputTypesRule.VariablesAreInputTypesRule;
+exports.VariablesInAllowedPositionRule = VariablesInAllowedPositionRule.VariablesInAllowedPositionRule;
+exports.LoneSchemaDefinitionRule = LoneSchemaDefinitionRule.LoneSchemaDefinitionRule;
+exports.UniqueOperationTypesRule = UniqueOperationTypesRule.UniqueOperationTypesRule;
+exports.UniqueTypeNamesRule = UniqueTypeNamesRule.UniqueTypeNamesRule;
+exports.UniqueEnumValueNamesRule = UniqueEnumValueNamesRule.UniqueEnumValueNamesRule;
+exports.UniqueFieldDefinitionNamesRule = UniqueFieldDefinitionNamesRule.UniqueFieldDefinitionNamesRule;
+exports.UniqueArgumentDefinitionNamesRule = UniqueArgumentDefinitionNamesRule.UniqueArgumentDefinitionNamesRule;
+exports.UniqueDirectiveNamesRule = UniqueDirectiveNamesRule.UniqueDirectiveNamesRule;
+exports.PossibleTypeExtensionsRule = PossibleTypeExtensionsRule.PossibleTypeExtensionsRule;
+exports.NoDeprecatedCustomRule = NoDeprecatedCustomRule.NoDeprecatedCustomRule;
+exports.NoSchemaIntrospectionCustomRule = NoSchemaIntrospectionCustomRule.NoSchemaIntrospectionCustomRule;
+exports.GraphQLError = GraphQLError.GraphQLError;
+exports.formatError = GraphQLError.formatError;
+exports.printError = GraphQLError.printError;
+exports.syntaxError = syntaxError.syntaxError;
+exports.locatedError = locatedError.locatedError;
+exports.getIntrospectionQuery = getIntrospectionQuery.getIntrospectionQuery;
+exports.getOperationAST = getOperationAST.getOperationAST;
+exports.getOperationRootType = getOperationRootType.getOperationRootType;
+exports.introspectionFromSchema = introspectionFromSchema.introspectionFromSchema;
+exports.buildClientSchema = buildClientSchema.buildClientSchema;
+exports.buildASTSchema = buildASTSchema.buildASTSchema;
+exports.buildSchema = buildASTSchema.buildSchema;
+exports.extendSchema = extendSchema.extendSchema;
+exports.lexicographicSortSchema = lexicographicSortSchema.lexicographicSortSchema;
+exports.printIntrospectionSchema = printSchema.printIntrospectionSchema;
+exports.printSchema = printSchema.printSchema;
+exports.printType = printSchema.printType;
+exports.typeFromAST = typeFromAST.typeFromAST;
+exports.valueFromAST = valueFromAST.valueFromAST;
+exports.valueFromASTUntyped = valueFromASTUntyped.valueFromASTUntyped;
+exports.astFromValue = astFromValue.astFromValue;
+exports.TypeInfo = TypeInfo.TypeInfo;
+exports.visitWithTypeInfo = TypeInfo.visitWithTypeInfo;
+exports.coerceInputValue = coerceInputValue.coerceInputValue;
+exports.concatAST = concatAST.concatAST;
+exports.separateOperations = separateOperations.separateOperations;
+exports.stripIgnoredCharacters = stripIgnoredCharacters.stripIgnoredCharacters;
+exports.doTypesOverlap = typeComparators.doTypesOverlap;
+exports.isEqualType = typeComparators.isEqualType;
+exports.isTypeSubTypeOf = typeComparators.isTypeSubTypeOf;
+exports.assertValidName = assertValidName.assertValidName;
+exports.isValidNameError = assertValidName.isValidNameError;
+Object.defineProperty(exports, "BreakingChangeType", {
+  enumerable: true,
+  get: () => findBreakingChanges.BreakingChangeType
+});
+Object.defineProperty(exports, "DangerousChangeType", {
+  enumerable: true,
+  get: () => findBreakingChanges.DangerousChangeType
+});
+exports.findBreakingChanges = findBreakingChanges.findBreakingChanges;
+exports.findDangerousChanges = findBreakingChanges.findDangerousChanges;
+//# sourceMappingURL=index.cjs.map

package/dist/__node_modules/graphql/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/__node_modules/graphql/index.js

@@ -0,0 +1,299 @@
+import { version, versionInfo } from "./version.js";
+import { graphql, graphqlSync } from "./graphql.js";
+import { GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLUnionType, assertAbstractType, assertCompositeType, assertEnumType, assertInputObjectType, assertInputType, assertInterfaceType, assertLeafType, assertListType, assertNamedType, assertNonNullType, assertNullableType, assertObjectType, assertOutputType, assertScalarType, assertType, assertUnionType, assertWrappingType, getNamedType, getNullableType, isAbstractType, isCompositeType, isEnumType, isInputObjectType, isInputType, isInterfaceType, isLeafType, isListType, isNamedType, isNonNullType, isNullableType, isObjectType, isOutputType, isRequiredArgument, isRequiredInputField, isScalarType, isType, isUnionType, isWrappingType, resolveObjMapThunk, resolveReadonlyArrayThunk } from "./type/definition.js";
+import { GraphQLSchema, assertSchema, isSchema } from "./type/schema.js";
+import { DEFAULT_DEPRECATION_REASON, GraphQLDeprecatedDirective, GraphQLDirective, GraphQLIncludeDirective, GraphQLSkipDirective, GraphQLSpecifiedByDirective, assertDirective, isDirective, isSpecifiedDirective, specifiedDirectives } from "./type/directives.js";
+import { GRAPHQL_MAX_INT, GRAPHQL_MIN_INT, GraphQLBoolean, GraphQLFloat, GraphQLID, GraphQLInt, GraphQLString, isSpecifiedScalarType, specifiedScalarTypes } from "./type/scalars.js";
+import { SchemaMetaFieldDef, TypeKind, TypeMetaFieldDef, TypeNameMetaFieldDef, __Directive, __DirectiveLocation, __EnumValue, __Field, __InputValue, __Schema, __Type, __TypeKind, introspectionTypes, isIntrospectionType } from "./type/introspection.js";
+import { assertValidSchema, validateSchema } from "./type/validate.js";
+import { assertEnumValueName, assertName } from "./type/assertName.js";
+import { Location, OperationTypeNode, Token } from "./language/ast.js";
+import { Source } from "./language/source.js";
+import { getLocation } from "./language/location.js";
+import { printLocation, printSourceLocation } from "./language/printLocation.js";
+import { Lexer } from "./language/lexer.js";
+import { TokenKind } from "./language/tokenKind.js";
+import { parse, parseConstValue, parseType, parseValue } from "./language/parser.js";
+import { print } from "./language/printer.js";
+import { BREAK, getEnterLeaveForKind, getVisitFn, visit, visitInParallel } from "./language/visitor.js";
+import { Kind } from "./language/kinds.js";
+import { DirectiveLocation } from "./language/directiveLocation.js";
+import { isConstValueNode, isDefinitionNode, isExecutableDefinitionNode, isSelectionNode, isTypeDefinitionNode, isTypeExtensionNode, isTypeNode, isTypeSystemDefinitionNode, isTypeSystemExtensionNode, isValueNode } from "./language/predicates.js";
+import { defaultFieldResolver, defaultTypeResolver, execute, executeSync } from "./execution/execute.js";
+import { pathToArray } from "./jsutils/Path.js";
+import { getArgumentValues, getDirectiveValues, getVariableValues } from "./execution/values.js";
+import { createSourceEventStream, subscribe } from "./execution/subscribe.js";
+import { validate } from "./validation/validate.js";
+import { ValidationContext } from "./validation/ValidationContext.js";
+import { specifiedRules } from "./validation/specifiedRules.js";
+import { ExecutableDefinitionsRule } from "./validation/rules/ExecutableDefinitionsRule.js";
+import { FieldsOnCorrectTypeRule } from "./validation/rules/FieldsOnCorrectTypeRule.js";
+import { FragmentsOnCompositeTypesRule } from "./validation/rules/FragmentsOnCompositeTypesRule.js";
+import { KnownArgumentNamesRule } from "./validation/rules/KnownArgumentNamesRule.js";
+import { KnownDirectivesRule } from "./validation/rules/KnownDirectivesRule.js";
+import { KnownFragmentNamesRule } from "./validation/rules/KnownFragmentNamesRule.js";
+import { KnownTypeNamesRule } from "./validation/rules/KnownTypeNamesRule.js";
+import { LoneAnonymousOperationRule } from "./validation/rules/LoneAnonymousOperationRule.js";
+import { NoFragmentCyclesRule } from "./validation/rules/NoFragmentCyclesRule.js";
+import { NoUndefinedVariablesRule } from "./validation/rules/NoUndefinedVariablesRule.js";
+import { NoUnusedFragmentsRule } from "./validation/rules/NoUnusedFragmentsRule.js";
+import { NoUnusedVariablesRule } from "./validation/rules/NoUnusedVariablesRule.js";
+import { OverlappingFieldsCanBeMergedRule } from "./validation/rules/OverlappingFieldsCanBeMergedRule.js";
+import { PossibleFragmentSpreadsRule } from "./validation/rules/PossibleFragmentSpreadsRule.js";
+import { ProvidedRequiredArgumentsRule } from "./validation/rules/ProvidedRequiredArgumentsRule.js";
+import { ScalarLeafsRule } from "./validation/rules/ScalarLeafsRule.js";
+import { SingleFieldSubscriptionsRule } from "./validation/rules/SingleFieldSubscriptionsRule.js";
+import { UniqueArgumentNamesRule } from "./validation/rules/UniqueArgumentNamesRule.js";
+import { UniqueDirectivesPerLocationRule } from "./validation/rules/UniqueDirectivesPerLocationRule.js";
+import { UniqueFragmentNamesRule } from "./validation/rules/UniqueFragmentNamesRule.js";
+import { UniqueInputFieldNamesRule } from "./validation/rules/UniqueInputFieldNamesRule.js";
+import { UniqueOperationNamesRule } from "./validation/rules/UniqueOperationNamesRule.js";
+import { UniqueVariableNamesRule } from "./validation/rules/UniqueVariableNamesRule.js";
+import { ValuesOfCorrectTypeRule } from "./validation/rules/ValuesOfCorrectTypeRule.js";
+import { VariablesAreInputTypesRule } from "./validation/rules/VariablesAreInputTypesRule.js";
+import { VariablesInAllowedPositionRule } from "./validation/rules/VariablesInAllowedPositionRule.js";
+import { LoneSchemaDefinitionRule } from "./validation/rules/LoneSchemaDefinitionRule.js";
+import { UniqueOperationTypesRule } from "./validation/rules/UniqueOperationTypesRule.js";
+import { UniqueTypeNamesRule } from "./validation/rules/UniqueTypeNamesRule.js";
+import { UniqueEnumValueNamesRule } from "./validation/rules/UniqueEnumValueNamesRule.js";
+import { UniqueFieldDefinitionNamesRule } from "./validation/rules/UniqueFieldDefinitionNamesRule.js";
+import { UniqueArgumentDefinitionNamesRule } from "./validation/rules/UniqueArgumentDefinitionNamesRule.js";
+import { UniqueDirectiveNamesRule } from "./validation/rules/UniqueDirectiveNamesRule.js";
+import { PossibleTypeExtensionsRule } from "./validation/rules/PossibleTypeExtensionsRule.js";
+import { NoDeprecatedCustomRule } from "./validation/rules/custom/NoDeprecatedCustomRule.js";
+import { NoSchemaIntrospectionCustomRule } from "./validation/rules/custom/NoSchemaIntrospectionCustomRule.js";
+import { GraphQLError, formatError, printError } from "./error/GraphQLError.js";
+import { syntaxError } from "./error/syntaxError.js";
+import { locatedError } from "./error/locatedError.js";
+import { getIntrospectionQuery } from "./utilities/getIntrospectionQuery.js";
+import { getOperationAST } from "./utilities/getOperationAST.js";
+import { getOperationRootType } from "./utilities/getOperationRootType.js";
+import { introspectionFromSchema } from "./utilities/introspectionFromSchema.js";
+import { buildClientSchema } from "./utilities/buildClientSchema.js";
+import { buildASTSchema, buildSchema } from "./utilities/buildASTSchema.js";
+import { extendSchema } from "./utilities/extendSchema.js";
+import { lexicographicSortSchema } from "./utilities/lexicographicSortSchema.js";
+import { printIntrospectionSchema, printSchema, printType } from "./utilities/printSchema.js";
+import { typeFromAST } from "./utilities/typeFromAST.js";
+import { valueFromAST } from "./utilities/valueFromAST.js";
+import { valueFromASTUntyped } from "./utilities/valueFromASTUntyped.js";
+import { astFromValue } from "./utilities/astFromValue.js";
+import { TypeInfo, visitWithTypeInfo } from "./utilities/TypeInfo.js";
+import { coerceInputValue } from "./utilities/coerceInputValue.js";
+import { concatAST } from "./utilities/concatAST.js";
+import { separateOperations } from "./utilities/separateOperations.js";
+import { stripIgnoredCharacters } from "./utilities/stripIgnoredCharacters.js";
+import { doTypesOverlap, isEqualType, isTypeSubTypeOf } from "./utilities/typeComparators.js";
+import { assertValidName, isValidNameError } from "./utilities/assertValidName.js";
+import { BreakingChangeType, DangerousChangeType, findBreakingChanges, findDangerousChanges } from "./utilities/findBreakingChanges.js";
+export {
+  BREAK,
+  BreakingChangeType,
+  DEFAULT_DEPRECATION_REASON,
+  DangerousChangeType,
+  DirectiveLocation,
+  ExecutableDefinitionsRule,
+  FieldsOnCorrectTypeRule,
+  FragmentsOnCompositeTypesRule,
+  GRAPHQL_MAX_INT,
+  GRAPHQL_MIN_INT,
+  GraphQLBoolean,
+  GraphQLDeprecatedDirective,
+  GraphQLDirective,
+  GraphQLEnumType,
+  GraphQLError,
+  GraphQLFloat,
+  GraphQLID,
+  GraphQLIncludeDirective,
+  GraphQLInputObjectType,
+  GraphQLInt,
+  GraphQLInterfaceType,
+  GraphQLList,
+  GraphQLNonNull,
+  GraphQLObjectType,
+  GraphQLScalarType,
+  GraphQLSchema,
+  GraphQLSkipDirective,
+  GraphQLSpecifiedByDirective,
+  GraphQLString,
+  GraphQLUnionType,
+  Kind,
+  KnownArgumentNamesRule,
+  KnownDirectivesRule,
+  KnownFragmentNamesRule,
+  KnownTypeNamesRule,
+  Lexer,
+  Location,
+  LoneAnonymousOperationRule,
+  LoneSchemaDefinitionRule,
+  NoDeprecatedCustomRule,
+  NoFragmentCyclesRule,
+  NoSchemaIntrospectionCustomRule,
+  NoUndefinedVariablesRule,
+  NoUnusedFragmentsRule,
+  NoUnusedVariablesRule,
+  OperationTypeNode,
+  OverlappingFieldsCanBeMergedRule,
+  PossibleFragmentSpreadsRule,
+  PossibleTypeExtensionsRule,
+  ProvidedRequiredArgumentsRule,
+  ScalarLeafsRule,
+  SchemaMetaFieldDef,
+  SingleFieldSubscriptionsRule,
+  Source,
+  Token,
+  TokenKind,
+  TypeInfo,
+  TypeKind,
+  TypeMetaFieldDef,
+  TypeNameMetaFieldDef,
+  UniqueArgumentDefinitionNamesRule,
+  UniqueArgumentNamesRule,
+  UniqueDirectiveNamesRule,
+  UniqueDirectivesPerLocationRule,
+  UniqueEnumValueNamesRule,
+  UniqueFieldDefinitionNamesRule,
+  UniqueFragmentNamesRule,
+  UniqueInputFieldNamesRule,
+  UniqueOperationNamesRule,
+  UniqueOperationTypesRule,
+  UniqueTypeNamesRule,
+  UniqueVariableNamesRule,
+  ValidationContext,
+  ValuesOfCorrectTypeRule,
+  VariablesAreInputTypesRule,
+  VariablesInAllowedPositionRule,
+  __Directive,
+  __DirectiveLocation,
+  __EnumValue,
+  __Field,
+  __InputValue,
+  __Schema,
+  __Type,
+  __TypeKind,
+  assertAbstractType,
+  assertCompositeType,
+  assertDirective,
+  assertEnumType,
+  assertEnumValueName,
+  assertInputObjectType,
+  assertInputType,
+  assertInterfaceType,
+  assertLeafType,
+  assertListType,
+  assertName,
+  assertNamedType,
+  assertNonNullType,
+  assertNullableType,
+  assertObjectType,
+  assertOutputType,
+  assertScalarType,
+  assertSchema,
+  assertType,
+  assertUnionType,
+  assertValidName,
+  assertValidSchema,
+  assertWrappingType,
+  astFromValue,
+  buildASTSchema,
+  buildClientSchema,
+  buildSchema,
+  coerceInputValue,
+  concatAST,
+  createSourceEventStream,
+  defaultFieldResolver,
+  defaultTypeResolver,
+  doTypesOverlap,
+  execute,
+  executeSync,
+  extendSchema,
+  findBreakingChanges,
+  findDangerousChanges,
+  formatError,
+  getArgumentValues,
+  getDirectiveValues,
+  getEnterLeaveForKind,
+  getIntrospectionQuery,
+  getLocation,
+  getNamedType,
+  getNullableType,
+  getOperationAST,
+  getOperationRootType,
+  getVariableValues,
+  getVisitFn,
+  graphql,
+  graphqlSync,
+  introspectionFromSchema,
+  introspectionTypes,
+  isAbstractType,
+  isCompositeType,
+  isConstValueNode,
+  isDefinitionNode,
+  isDirective,
+  isEnumType,
+  isEqualType,
+  isExecutableDefinitionNode,
+  isInputObjectType,
+  isInputType,
+  isInterfaceType,
+  isIntrospectionType,
+  isLeafType,
+  isListType,
+  isNamedType,
+  isNonNullType,
+  isNullableType,
+  isObjectType,
+  isOutputType,
+  isRequiredArgument,
+  isRequiredInputField,
+  isScalarType,
+  isSchema,
+  isSelectionNode,
+  isSpecifiedDirective,
+  isSpecifiedScalarType,
+  isType,
+  isTypeDefinitionNode,
+  isTypeExtensionNode,
+  isTypeNode,
+  isTypeSubTypeOf,
+  isTypeSystemDefinitionNode,
+  isTypeSystemExtensionNode,
+  isUnionType,
+  isValidNameError,
+  isValueNode,
+  isWrappingType,
+  lexicographicSortSchema,
+  locatedError,
+  parse,
+  parseConstValue,
+  parseType,
+  parseValue,
+  print,
+  printError,
+  printIntrospectionSchema,
+  printLocation,
+  printSchema,
+  printSourceLocation,
+  printType,
+  resolveObjMapThunk,
+  resolveReadonlyArrayThunk,
+  pathToArray as responsePathAsArray,
+  separateOperations,
+  specifiedDirectives,
+  specifiedRules,
+  specifiedScalarTypes,
+  stripIgnoredCharacters,
+  subscribe,
+  syntaxError,
+  typeFromAST,
+  validate,
+  validateSchema,
+  valueFromAST,
+  valueFromASTUntyped,
+  version,
+  versionInfo,
+  visit,
+  visitInParallel,
+  visitWithTypeInfo
+};
+//# sourceMappingURL=index.js.map

package/dist/__node_modules/graphql/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/__node_modules/graphql/jsutils/Path.cjs

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function addPath(prev, key, typename) {
+  return {
+    prev,
+    key,
+    typename
+  };
+}
+function pathToArray(path) {
+  const flattened = [];
+  let curr = path;
+  while (curr) {
+    flattened.push(curr.key);
+    curr = curr.prev;
+  }
+  return flattened.reverse();
+}
+exports.addPath = addPath;
+exports.pathToArray = pathToArray;
+//# sourceMappingURL=Path.cjs.map

package/dist/__node_modules/graphql/jsutils/Path.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Path.cjs","sources":["../../../../../../node_modules/graphql/jsutils/Path.mjs"],"sourcesContent":["/**\n * Given a Path and a key, return a new Path containing the new key.\n */\nexport function addPath(prev, key, typename) {\n  return {\n    prev,\n    key,\n    typename,\n  };\n}\n/**\n * Given a Path, return an Array of the path keys.\n */\n\nexport function pathToArray(path) {\n  const flattened = [];\n  let curr = path;\n\n  while (curr) {\n    flattened.push(curr.key);\n    curr = curr.prev;\n  }\n\n  return flattened.reverse();\n}\n"],"names":[],"mappings":";;AAGO,SAAS,QAAQ,MAAM,KAAK,UAAU;AAC3C,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACJ;AACA;AAKO,SAAS,YAAY,MAAM;AAChC,QAAM,YAAY,CAAA;AAClB,MAAI,OAAO;AAEX,SAAO,MAAM;AACX,cAAU,KAAK,KAAK,GAAG;AACvB,WAAO,KAAK;AAAA,EACb;AAED,SAAO,UAAU;AACnB;;;"}