@slicemachine/manager 0.1.1-dev-plugins.3

package/dist/__node_modules/graphql/utilities/stripIgnoredCharacters.cjs

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const blockString = require("../language/blockString.cjs");
+const lexer = require("../language/lexer.cjs");
+const source = require("../language/source.cjs");
+const tokenKind = require("../language/tokenKind.cjs");
+function stripIgnoredCharacters(source$1) {
+  const sourceObj = source.isSource(source$1) ? source$1 : new source.Source(source$1);
+  const body = sourceObj.body;
+  const lexer$1 = new lexer.Lexer(sourceObj);
+  let strippedBody = "";
+  let wasLastAddedTokenNonPunctuator = false;
+  while (lexer$1.advance().kind !== tokenKind.TokenKind.EOF) {
+    const currentToken = lexer$1.token;
+    const tokenKind$1 = currentToken.kind;
+    const isNonPunctuator = !lexer.isPunctuatorTokenKind(currentToken.kind);
+    if (wasLastAddedTokenNonPunctuator) {
+      if (isNonPunctuator || currentToken.kind === tokenKind.TokenKind.SPREAD) {
+        strippedBody += " ";
+      }
+    }
+    const tokenBody = body.slice(currentToken.start, currentToken.end);
+    if (tokenKind$1 === tokenKind.TokenKind.BLOCK_STRING) {
+      strippedBody += blockString.printBlockString(currentToken.value, {
+        minimize: true
+      });
+    } else {
+      strippedBody += tokenBody;
+    }
+    wasLastAddedTokenNonPunctuator = isNonPunctuator;
+  }
+  return strippedBody;
+}
+exports.stripIgnoredCharacters = stripIgnoredCharacters;
+//# sourceMappingURL=stripIgnoredCharacters.cjs.map

package/dist/__node_modules/graphql/utilities/stripIgnoredCharacters.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripIgnoredCharacters.cjs","sources":["../../../../../../node_modules/graphql/utilities/stripIgnoredCharacters.mjs"],"sourcesContent":["import { printBlockString } from '../language/blockString.mjs';\nimport { isPunctuatorTokenKind, Lexer } from '../language/lexer.mjs';\nimport { isSource, Source } from '../language/source.mjs';\nimport { TokenKind } from '../language/tokenKind.mjs';\n/**\n * Strips characters that are not significant to the validity or execution\n * of a GraphQL document:\n *   - UnicodeBOM\n *   - WhiteSpace\n *   - LineTerminator\n *   - Comment\n *   - Comma\n *   - BlockString indentation\n *\n * Note: It is required to have a delimiter character between neighboring\n * non-punctuator tokens and this function always uses single space as delimiter.\n *\n * It is guaranteed that both input and output documents if parsed would result\n * in the exact same AST except for nodes location.\n *\n * Warning: It is guaranteed that this function will always produce stable results.\n * However, it's not guaranteed that it will stay the same between different\n * releases due to bugfixes or changes in the GraphQL specification.\n *\n * Query example:\n *\n * ```graphql\n * query SomeQuery($foo: String!, $bar: String) {\n *   someField(foo: $foo, bar: $bar) {\n *     a\n *     b {\n *       c\n *       d\n *     }\n *   }\n * }\n * ```\n *\n * Becomes:\n *\n * ```graphql\n * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}\n * ```\n *\n * SDL example:\n *\n * ```graphql\n * \"\"\"\n * Type description\n * \"\"\"\n * type Foo {\n *   \"\"\"\n *   Field description\n *   \"\"\"\n *   bar: String\n * }\n * ```\n *\n * Becomes:\n *\n * ```graphql\n * \"\"\"Type description\"\"\" type Foo{\"\"\"Field description\"\"\" bar:String}\n * ```\n */\n\nexport function stripIgnoredCharacters(source) {\n  const sourceObj = isSource(source) ? source : new Source(source);\n  const body = sourceObj.body;\n  const lexer = new Lexer(sourceObj);\n  let strippedBody = '';\n  let wasLastAddedTokenNonPunctuator = false;\n\n  while (lexer.advance().kind !== TokenKind.EOF) {\n    const currentToken = lexer.token;\n    const tokenKind = currentToken.kind;\n    /**\n     * Every two non-punctuator tokens should have space between them.\n     * Also prevent case of non-punctuator token following by spread resulting\n     * in invalid token (e.g. `1...` is invalid Float token).\n     */\n\n    const isNonPunctuator = !isPunctuatorTokenKind(currentToken.kind);\n\n    if (wasLastAddedTokenNonPunctuator) {\n      if (isNonPunctuator || currentToken.kind === TokenKind.SPREAD) {\n        strippedBody += ' ';\n      }\n    }\n\n    const tokenBody = body.slice(currentToken.start, currentToken.end);\n\n    if (tokenKind === TokenKind.BLOCK_STRING) {\n      strippedBody += printBlockString(currentToken.value, {\n        minimize: true,\n      });\n    } else {\n      strippedBody += tokenBody;\n    }\n\n    wasLastAddedTokenNonPunctuator = isNonPunctuator;\n  }\n\n  return strippedBody;\n}\n"],"names":["source","isSource","Source","lexer","Lexer","TokenKind","tokenKind","isPunctuatorTokenKind","printBlockString"],"mappings":";;;;;;AAiEO,SAAS,uBAAuBA,UAAQ;AAC7C,QAAM,YAAYC,OAAAA,SAASD,QAAM,IAAIA,WAAS,IAAIE,OAAAA,OAAOF,QAAM;AAC/D,QAAM,OAAO,UAAU;AACvB,QAAMG,UAAQ,IAAIC,YAAM,SAAS;AACjC,MAAI,eAAe;AACnB,MAAI,iCAAiC;AAErC,SAAOD,QAAM,QAAO,EAAG,SAASE,UAAAA,UAAU,KAAK;AAC7C,UAAM,eAAeF,QAAM;AAC3B,UAAMG,cAAY,aAAa;AAO/B,UAAM,kBAAkB,CAACC,MAAAA,sBAAsB,aAAa,IAAI;AAEhE,QAAI,gCAAgC;AAClC,UAAI,mBAAmB,aAAa,SAASF,UAAAA,UAAU,QAAQ;AAC7D,wBAAgB;AAAA,MACjB;AAAA,IACF;AAED,UAAM,YAAY,KAAK,MAAM,aAAa,OAAO,aAAa,GAAG;AAEjE,QAAIC,gBAAcD,UAAS,UAAC,cAAc;AACxC,sBAAgBG,YAAAA,iBAAiB,aAAa,OAAO;AAAA,QACnD,UAAU;AAAA,MAClB,CAAO;AAAA,IACP,OAAW;AACL,sBAAgB;AAAA,IACjB;AAED,qCAAiC;AAAA,EAClC;AAED,SAAO;AACT;;"}

package/dist/__node_modules/graphql/utilities/stripIgnoredCharacters.js

@@ -0,0 +1,35 @@
+import { printBlockString } from "../language/blockString.js";
+import { Lexer, isPunctuatorTokenKind } from "../language/lexer.js";
+import { isSource, Source } from "../language/source.js";
+import { TokenKind } from "../language/tokenKind.js";
+function stripIgnoredCharacters(source) {
+  const sourceObj = isSource(source) ? source : new Source(source);
+  const body = sourceObj.body;
+  const lexer = new Lexer(sourceObj);
+  let strippedBody = "";
+  let wasLastAddedTokenNonPunctuator = false;
+  while (lexer.advance().kind !== TokenKind.EOF) {
+    const currentToken = lexer.token;
+    const tokenKind = currentToken.kind;
+    const isNonPunctuator = !isPunctuatorTokenKind(currentToken.kind);
+    if (wasLastAddedTokenNonPunctuator) {
+      if (isNonPunctuator || currentToken.kind === TokenKind.SPREAD) {
+        strippedBody += " ";
+      }
+    }
+    const tokenBody = body.slice(currentToken.start, currentToken.end);
+    if (tokenKind === TokenKind.BLOCK_STRING) {
+      strippedBody += printBlockString(currentToken.value, {
+        minimize: true
+      });
+    } else {
+      strippedBody += tokenBody;
+    }
+    wasLastAddedTokenNonPunctuator = isNonPunctuator;
+  }
+  return strippedBody;
+}
+export {
+  stripIgnoredCharacters
+};
+//# sourceMappingURL=stripIgnoredCharacters.js.map

package/dist/__node_modules/graphql/utilities/stripIgnoredCharacters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripIgnoredCharacters.js","sources":["../../../../../../node_modules/graphql/utilities/stripIgnoredCharacters.mjs"],"sourcesContent":["import { printBlockString } from '../language/blockString.mjs';\nimport { isPunctuatorTokenKind, Lexer } from '../language/lexer.mjs';\nimport { isSource, Source } from '../language/source.mjs';\nimport { TokenKind } from '../language/tokenKind.mjs';\n/**\n * Strips characters that are not significant to the validity or execution\n * of a GraphQL document:\n *   - UnicodeBOM\n *   - WhiteSpace\n *   - LineTerminator\n *   - Comment\n *   - Comma\n *   - BlockString indentation\n *\n * Note: It is required to have a delimiter character between neighboring\n * non-punctuator tokens and this function always uses single space as delimiter.\n *\n * It is guaranteed that both input and output documents if parsed would result\n * in the exact same AST except for nodes location.\n *\n * Warning: It is guaranteed that this function will always produce stable results.\n * However, it's not guaranteed that it will stay the same between different\n * releases due to bugfixes or changes in the GraphQL specification.\n *\n * Query example:\n *\n * ```graphql\n * query SomeQuery($foo: String!, $bar: String) {\n *   someField(foo: $foo, bar: $bar) {\n *     a\n *     b {\n *       c\n *       d\n *     }\n *   }\n * }\n * ```\n *\n * Becomes:\n *\n * ```graphql\n * query SomeQuery($foo:String!$bar:String){someField(foo:$foo bar:$bar){a b{c d}}}\n * ```\n *\n * SDL example:\n *\n * ```graphql\n * \"\"\"\n * Type description\n * \"\"\"\n * type Foo {\n *   \"\"\"\n *   Field description\n *   \"\"\"\n *   bar: String\n * }\n * ```\n *\n * Becomes:\n *\n * ```graphql\n * \"\"\"Type description\"\"\" type Foo{\"\"\"Field description\"\"\" bar:String}\n * ```\n */\n\nexport function stripIgnoredCharacters(source) {\n  const sourceObj = isSource(source) ? source : new Source(source);\n  const body = sourceObj.body;\n  const lexer = new Lexer(sourceObj);\n  let strippedBody = '';\n  let wasLastAddedTokenNonPunctuator = false;\n\n  while (lexer.advance().kind !== TokenKind.EOF) {\n    const currentToken = lexer.token;\n    const tokenKind = currentToken.kind;\n    /**\n     * Every two non-punctuator tokens should have space between them.\n     * Also prevent case of non-punctuator token following by spread resulting\n     * in invalid token (e.g. `1...` is invalid Float token).\n     */\n\n    const isNonPunctuator = !isPunctuatorTokenKind(currentToken.kind);\n\n    if (wasLastAddedTokenNonPunctuator) {\n      if (isNonPunctuator || currentToken.kind === TokenKind.SPREAD) {\n        strippedBody += ' ';\n      }\n    }\n\n    const tokenBody = body.slice(currentToken.start, currentToken.end);\n\n    if (tokenKind === TokenKind.BLOCK_STRING) {\n      strippedBody += printBlockString(currentToken.value, {\n        minimize: true,\n      });\n    } else {\n      strippedBody += tokenBody;\n    }\n\n    wasLastAddedTokenNonPunctuator = isNonPunctuator;\n  }\n\n  return strippedBody;\n}\n"],"names":[],"mappings":";;;;AAiEO,SAAS,uBAAuB,QAAQ;AAC7C,QAAM,YAAY,SAAS,MAAM,IAAI,SAAS,IAAI,OAAO,MAAM;AAC/D,QAAM,OAAO,UAAU;AACvB,QAAM,QAAQ,IAAI,MAAM,SAAS;AACjC,MAAI,eAAe;AACnB,MAAI,iCAAiC;AAErC,SAAO,MAAM,QAAO,EAAG,SAAS,UAAU,KAAK;AAC7C,UAAM,eAAe,MAAM;AAC3B,UAAM,YAAY,aAAa;AAO/B,UAAM,kBAAkB,CAAC,sBAAsB,aAAa,IAAI;AAEhE,QAAI,gCAAgC;AAClC,UAAI,mBAAmB,aAAa,SAAS,UAAU,QAAQ;AAC7D,wBAAgB;AAAA,MACjB;AAAA,IACF;AAED,UAAM,YAAY,KAAK,MAAM,aAAa,OAAO,aAAa,GAAG;AAEjE,QAAI,cAAc,UAAU,cAAc;AACxC,sBAAgB,iBAAiB,aAAa,OAAO;AAAA,QACnD,UAAU;AAAA,MAClB,CAAO;AAAA,IACP,OAAW;AACL,sBAAgB;AAAA,IACjB;AAED,qCAAiC;AAAA,EAClC;AAED,SAAO;AACT;"}

package/dist/__node_modules/graphql/utilities/typeComparators.cjs

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const definition = require("../type/definition.cjs");
+function isEqualType(typeA, typeB) {
+  if (typeA === typeB) {
+    return true;
+  }
+  if (definition.isNonNullType(typeA) && definition.isNonNullType(typeB)) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  }
+  if (definition.isListType(typeA) && definition.isListType(typeB)) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  }
+  return false;
+}
+function isTypeSubTypeOf(schema, maybeSubType, superType) {
+  if (maybeSubType === superType) {
+    return true;
+  }
+  if (definition.isNonNullType(superType)) {
+    if (definition.isNonNullType(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+    return false;
+  }
+  if (definition.isNonNullType(maybeSubType)) {
+    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
+  }
+  if (definition.isListType(superType)) {
+    if (definition.isListType(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+    return false;
+  }
+  if (definition.isListType(maybeSubType)) {
+    return false;
+  }
+  return definition.isAbstractType(superType) && (definition.isInterfaceType(maybeSubType) || definition.isObjectType(maybeSubType)) && schema.isSubType(superType, maybeSubType);
+}
+function doTypesOverlap(schema, typeA, typeB) {
+  if (typeA === typeB) {
+    return true;
+  }
+  if (definition.isAbstractType(typeA)) {
+    if (definition.isAbstractType(typeB)) {
+      return schema.getPossibleTypes(typeA).some((type) => schema.isSubType(typeB, type));
+    }
+    return schema.isSubType(typeA, typeB);
+  }
+  if (definition.isAbstractType(typeB)) {
+    return schema.isSubType(typeB, typeA);
+  }
+  return false;
+}
+exports.doTypesOverlap = doTypesOverlap;
+exports.isEqualType = isEqualType;
+exports.isTypeSubTypeOf = isTypeSubTypeOf;
+//# sourceMappingURL=typeComparators.cjs.map

package/dist/__node_modules/graphql/utilities/typeComparators.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeComparators.cjs","sources":["../../../../../../node_modules/graphql/utilities/typeComparators.mjs"],"sourcesContent":["import {\n  isAbstractType,\n  isInterfaceType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../type/definition.mjs';\n\n/**\n * Provided two types, return true if the types are equal (invariant).\n */\nexport function isEqualType(typeA, typeB) {\n  // Equivalent types are equal.\n  if (typeA === typeB) {\n    return true;\n  } // If either type is non-null, the other must also be non-null.\n\n  if (isNonNullType(typeA) && isNonNullType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  } // If either type is a list, the other must also be a list.\n\n  if (isListType(typeA) && isListType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  } // Otherwise the types are not equal.\n\n  return false;\n}\n/**\n * Provided a type and a super type, return true if the first type is either\n * equal or a subset of the second super type (covariant).\n */\n\nexport function isTypeSubTypeOf(schema, maybeSubType, superType) {\n  // Equivalent type is a valid subtype\n  if (maybeSubType === superType) {\n    return true;\n  } // If superType is non-null, maybeSubType must also be non-null.\n\n  if (isNonNullType(superType)) {\n    if (isNonNullType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n\n    return false;\n  }\n\n  if (isNonNullType(maybeSubType)) {\n    // If superType is nullable, maybeSubType may be non-null or nullable.\n    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);\n  } // If superType type is a list, maybeSubType type must also be a list.\n\n  if (isListType(superType)) {\n    if (isListType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n\n    return false;\n  }\n\n  if (isListType(maybeSubType)) {\n    // If superType is not a list, maybeSubType must also be not a list.\n    return false;\n  } // If superType type is an abstract type, check if it is super type of maybeSubType.\n  // Otherwise, the child type is not a valid subtype of the parent type.\n\n  return (\n    isAbstractType(superType) &&\n    (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&\n    schema.isSubType(superType, maybeSubType)\n  );\n}\n/**\n * Provided two composite types, determine if they \"overlap\". Two composite\n * types overlap when the Sets of possible concrete types for each intersect.\n *\n * This is often used to determine if a fragment of a given type could possibly\n * be visited in a context of another type.\n *\n * This function is commutative.\n */\n\nexport function doTypesOverlap(schema, typeA, typeB) {\n  // Equivalent types overlap\n  if (typeA === typeB) {\n    return true;\n  }\n\n  if (isAbstractType(typeA)) {\n    if (isAbstractType(typeB)) {\n      // If both types are abstract, then determine if there is any intersection\n      // between possible concrete types of each.\n      return schema\n        .getPossibleTypes(typeA)\n        .some((type) => schema.isSubType(typeB, type));\n    } // Determine if the latter type is a possible concrete type of the former.\n\n    return schema.isSubType(typeA, typeB);\n  }\n\n  if (isAbstractType(typeB)) {\n    // Determine if the former type is a possible concrete type of the latter.\n    return schema.isSubType(typeB, typeA);\n  } // Otherwise the types do not overlap.\n\n  return false;\n}\n"],"names":["isNonNullType","isListType","isAbstractType","isInterfaceType","isObjectType"],"mappings":";;;AAWO,SAAS,YAAY,OAAO,OAAO;AAExC,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACR;AAED,MAAIA,WAAa,cAAC,KAAK,KAAKA,WAAa,cAAC,KAAK,GAAG;AAChD,WAAO,YAAY,MAAM,QAAQ,MAAM,MAAM;AAAA,EAC9C;AAED,MAAIC,WAAU,WAAC,KAAK,KAAKA,WAAU,WAAC,KAAK,GAAG;AAC1C,WAAO,YAAY,MAAM,QAAQ,MAAM,MAAM;AAAA,EAC9C;AAED,SAAO;AACT;AAMO,SAAS,gBAAgB,QAAQ,cAAc,WAAW;AAE/D,MAAI,iBAAiB,WAAW;AAC9B,WAAO;AAAA,EACR;AAED,MAAID,WAAAA,cAAc,SAAS,GAAG;AAC5B,QAAIA,WAAAA,cAAc,YAAY,GAAG;AAC/B,aAAO,gBAAgB,QAAQ,aAAa,QAAQ,UAAU,MAAM;AAAA,IACrE;AAED,WAAO;AAAA,EACR;AAED,MAAIA,WAAAA,cAAc,YAAY,GAAG;AAE/B,WAAO,gBAAgB,QAAQ,aAAa,QAAQ,SAAS;AAAA,EAC9D;AAED,MAAIC,WAAAA,WAAW,SAAS,GAAG;AACzB,QAAIA,WAAAA,WAAW,YAAY,GAAG;AAC5B,aAAO,gBAAgB,QAAQ,aAAa,QAAQ,UAAU,MAAM;AAAA,IACrE;AAED,WAAO;AAAA,EACR;AAED,MAAIA,WAAAA,WAAW,YAAY,GAAG;AAE5B,WAAO;AAAA,EACR;AAGD,SACEC,WAAAA,eAAe,SAAS,MACvBC,WAAAA,gBAAgB,YAAY,KAAKC,WAAY,aAAC,YAAY,MAC3D,OAAO,UAAU,WAAW,YAAY;AAE5C;AAWO,SAAS,eAAe,QAAQ,OAAO,OAAO;AAEnD,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACR;AAED,MAAIF,WAAAA,eAAe,KAAK,GAAG;AACzB,QAAIA,WAAAA,eAAe,KAAK,GAAG;AAGzB,aAAO,OACJ,iBAAiB,KAAK,EACtB,KAAK,CAAC,SAAS,OAAO,UAAU,OAAO,IAAI,CAAC;AAAA,IAChD;AAED,WAAO,OAAO,UAAU,OAAO,KAAK;AAAA,EACrC;AAED,MAAIA,WAAAA,eAAe,KAAK,GAAG;AAEzB,WAAO,OAAO,UAAU,OAAO,KAAK;AAAA,EACrC;AAED,SAAO;AACT;;;;"}

package/dist/__node_modules/graphql/utilities/typeComparators.js

@@ -0,0 +1,58 @@
+import { isNonNullType, isListType, isAbstractType, isInterfaceType, isObjectType } from "../type/definition.js";
+function isEqualType(typeA, typeB) {
+  if (typeA === typeB) {
+    return true;
+  }
+  if (isNonNullType(typeA) && isNonNullType(typeB)) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  }
+  if (isListType(typeA) && isListType(typeB)) {
+    return isEqualType(typeA.ofType, typeB.ofType);
+  }
+  return false;
+}
+function isTypeSubTypeOf(schema, maybeSubType, superType) {
+  if (maybeSubType === superType) {
+    return true;
+  }
+  if (isNonNullType(superType)) {
+    if (isNonNullType(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+    return false;
+  }
+  if (isNonNullType(maybeSubType)) {
+    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);
+  }
+  if (isListType(superType)) {
+    if (isListType(maybeSubType)) {
+      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);
+    }
+    return false;
+  }
+  if (isListType(maybeSubType)) {
+    return false;
+  }
+  return isAbstractType(superType) && (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) && schema.isSubType(superType, maybeSubType);
+}
+function doTypesOverlap(schema, typeA, typeB) {
+  if (typeA === typeB) {
+    return true;
+  }
+  if (isAbstractType(typeA)) {
+    if (isAbstractType(typeB)) {
+      return schema.getPossibleTypes(typeA).some((type) => schema.isSubType(typeB, type));
+    }
+    return schema.isSubType(typeA, typeB);
+  }
+  if (isAbstractType(typeB)) {
+    return schema.isSubType(typeB, typeA);
+  }
+  return false;
+}
+export {
+  doTypesOverlap,
+  isEqualType,
+  isTypeSubTypeOf
+};
+//# sourceMappingURL=typeComparators.js.map

package/dist/__node_modules/graphql/utilities/typeComparators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeComparators.js","sources":["../../../../../../node_modules/graphql/utilities/typeComparators.mjs"],"sourcesContent":["import {\n  isAbstractType,\n  isInterfaceType,\n  isListType,\n  isNonNullType,\n  isObjectType,\n} from '../type/definition.mjs';\n\n/**\n * Provided two types, return true if the types are equal (invariant).\n */\nexport function isEqualType(typeA, typeB) {\n  // Equivalent types are equal.\n  if (typeA === typeB) {\n    return true;\n  } // If either type is non-null, the other must also be non-null.\n\n  if (isNonNullType(typeA) && isNonNullType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  } // If either type is a list, the other must also be a list.\n\n  if (isListType(typeA) && isListType(typeB)) {\n    return isEqualType(typeA.ofType, typeB.ofType);\n  } // Otherwise the types are not equal.\n\n  return false;\n}\n/**\n * Provided a type and a super type, return true if the first type is either\n * equal or a subset of the second super type (covariant).\n */\n\nexport function isTypeSubTypeOf(schema, maybeSubType, superType) {\n  // Equivalent type is a valid subtype\n  if (maybeSubType === superType) {\n    return true;\n  } // If superType is non-null, maybeSubType must also be non-null.\n\n  if (isNonNullType(superType)) {\n    if (isNonNullType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n\n    return false;\n  }\n\n  if (isNonNullType(maybeSubType)) {\n    // If superType is nullable, maybeSubType may be non-null or nullable.\n    return isTypeSubTypeOf(schema, maybeSubType.ofType, superType);\n  } // If superType type is a list, maybeSubType type must also be a list.\n\n  if (isListType(superType)) {\n    if (isListType(maybeSubType)) {\n      return isTypeSubTypeOf(schema, maybeSubType.ofType, superType.ofType);\n    }\n\n    return false;\n  }\n\n  if (isListType(maybeSubType)) {\n    // If superType is not a list, maybeSubType must also be not a list.\n    return false;\n  } // If superType type is an abstract type, check if it is super type of maybeSubType.\n  // Otherwise, the child type is not a valid subtype of the parent type.\n\n  return (\n    isAbstractType(superType) &&\n    (isInterfaceType(maybeSubType) || isObjectType(maybeSubType)) &&\n    schema.isSubType(superType, maybeSubType)\n  );\n}\n/**\n * Provided two composite types, determine if they \"overlap\". Two composite\n * types overlap when the Sets of possible concrete types for each intersect.\n *\n * This is often used to determine if a fragment of a given type could possibly\n * be visited in a context of another type.\n *\n * This function is commutative.\n */\n\nexport function doTypesOverlap(schema, typeA, typeB) {\n  // Equivalent types overlap\n  if (typeA === typeB) {\n    return true;\n  }\n\n  if (isAbstractType(typeA)) {\n    if (isAbstractType(typeB)) {\n      // If both types are abstract, then determine if there is any intersection\n      // between possible concrete types of each.\n      return schema\n        .getPossibleTypes(typeA)\n        .some((type) => schema.isSubType(typeB, type));\n    } // Determine if the latter type is a possible concrete type of the former.\n\n    return schema.isSubType(typeA, typeB);\n  }\n\n  if (isAbstractType(typeB)) {\n    // Determine if the former type is a possible concrete type of the latter.\n    return schema.isSubType(typeB, typeA);\n  } // Otherwise the types do not overlap.\n\n  return false;\n}\n"],"names":[],"mappings":";AAWO,SAAS,YAAY,OAAO,OAAO;AAExC,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACR;AAED,MAAI,cAAc,KAAK,KAAK,cAAc,KAAK,GAAG;AAChD,WAAO,YAAY,MAAM,QAAQ,MAAM,MAAM;AAAA,EAC9C;AAED,MAAI,WAAW,KAAK,KAAK,WAAW,KAAK,GAAG;AAC1C,WAAO,YAAY,MAAM,QAAQ,MAAM,MAAM;AAAA,EAC9C;AAED,SAAO;AACT;AAMO,SAAS,gBAAgB,QAAQ,cAAc,WAAW;AAE/D,MAAI,iBAAiB,WAAW;AAC9B,WAAO;AAAA,EACR;AAED,MAAI,cAAc,SAAS,GAAG;AAC5B,QAAI,cAAc,YAAY,GAAG;AAC/B,aAAO,gBAAgB,QAAQ,aAAa,QAAQ,UAAU,MAAM;AAAA,IACrE;AAED,WAAO;AAAA,EACR;AAED,MAAI,cAAc,YAAY,GAAG;AAE/B,WAAO,gBAAgB,QAAQ,aAAa,QAAQ,SAAS;AAAA,EAC9D;AAED,MAAI,WAAW,SAAS,GAAG;AACzB,QAAI,WAAW,YAAY,GAAG;AAC5B,aAAO,gBAAgB,QAAQ,aAAa,QAAQ,UAAU,MAAM;AAAA,IACrE;AAED,WAAO;AAAA,EACR;AAED,MAAI,WAAW,YAAY,GAAG;AAE5B,WAAO;AAAA,EACR;AAGD,SACE,eAAe,SAAS,MACvB,gBAAgB,YAAY,KAAK,aAAa,YAAY,MAC3D,OAAO,UAAU,WAAW,YAAY;AAE5C;AAWO,SAAS,eAAe,QAAQ,OAAO,OAAO;AAEnD,MAAI,UAAU,OAAO;AACnB,WAAO;AAAA,EACR;AAED,MAAI,eAAe,KAAK,GAAG;AACzB,QAAI,eAAe,KAAK,GAAG;AAGzB,aAAO,OACJ,iBAAiB,KAAK,EACtB,KAAK,CAAC,SAAS,OAAO,UAAU,OAAO,IAAI,CAAC;AAAA,IAChD;AAED,WAAO,OAAO,UAAU,OAAO,KAAK;AAAA,EACrC;AAED,MAAI,eAAe,KAAK,GAAG;AAEzB,WAAO,OAAO,UAAU,OAAO,KAAK;AAAA,EACrC;AAED,SAAO;AACT;"}

package/dist/__node_modules/graphql/utilities/typeFromAST.cjs

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const kinds = require("../language/kinds.cjs");
+const definition = require("../type/definition.cjs");
+function typeFromAST(schema, typeNode) {
+  switch (typeNode.kind) {
+    case kinds.Kind.LIST_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new definition.GraphQLList(innerType);
+    }
+    case kinds.Kind.NON_NULL_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new definition.GraphQLNonNull(innerType);
+    }
+    case kinds.Kind.NAMED_TYPE:
+      return schema.getType(typeNode.name.value);
+  }
+}
+exports.typeFromAST = typeFromAST;
+//# sourceMappingURL=typeFromAST.cjs.map

package/dist/__node_modules/graphql/utilities/typeFromAST.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeFromAST.cjs","sources":["../../../../../../node_modules/graphql/utilities/typeFromAST.mjs"],"sourcesContent":["import { Kind } from '../language/kinds.mjs';\nimport { GraphQLList, GraphQLNonNull } from '../type/definition.mjs';\nexport function typeFromAST(schema, typeNode) {\n  switch (typeNode.kind) {\n    case Kind.LIST_TYPE: {\n      const innerType = typeFromAST(schema, typeNode.type);\n      return innerType && new GraphQLList(innerType);\n    }\n\n    case Kind.NON_NULL_TYPE: {\n      const innerType = typeFromAST(schema, typeNode.type);\n      return innerType && new GraphQLNonNull(innerType);\n    }\n\n    case Kind.NAMED_TYPE:\n      return schema.getType(typeNode.name.value);\n  }\n}\n"],"names":["Kind","GraphQLList","GraphQLNonNull"],"mappings":";;;;AAEO,SAAS,YAAY,QAAQ,UAAU;AAC5C,UAAQ,SAAS,MAAI;AAAA,IACnB,KAAKA,MAAAA,KAAK,WAAW;AACnB,YAAM,YAAY,YAAY,QAAQ,SAAS,IAAI;AACnD,aAAO,aAAa,IAAIC,uBAAY,SAAS;AAAA,IAC9C;AAAA,IAED,KAAKD,MAAAA,KAAK,eAAe;AACvB,YAAM,YAAY,YAAY,QAAQ,SAAS,IAAI;AACnD,aAAO,aAAa,IAAIE,0BAAe,SAAS;AAAA,IACjD;AAAA,IAED,KAAKF,MAAI,KAAC;AACR,aAAO,OAAO,QAAQ,SAAS,KAAK,KAAK;AAAA,EAC5C;AACH;;"}

package/dist/__node_modules/graphql/utilities/typeFromAST.js

@@ -0,0 +1,20 @@
+import { Kind } from "../language/kinds.js";
+import { GraphQLNonNull, GraphQLList } from "../type/definition.js";
+function typeFromAST(schema, typeNode) {
+  switch (typeNode.kind) {
+    case Kind.LIST_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new GraphQLList(innerType);
+    }
+    case Kind.NON_NULL_TYPE: {
+      const innerType = typeFromAST(schema, typeNode.type);
+      return innerType && new GraphQLNonNull(innerType);
+    }
+    case Kind.NAMED_TYPE:
+      return schema.getType(typeNode.name.value);
+  }
+}
+export {
+  typeFromAST
+};
+//# sourceMappingURL=typeFromAST.js.map

package/dist/__node_modules/graphql/utilities/typeFromAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeFromAST.js","sources":["../../../../../../node_modules/graphql/utilities/typeFromAST.mjs"],"sourcesContent":["import { Kind } from '../language/kinds.mjs';\nimport { GraphQLList, GraphQLNonNull } from '../type/definition.mjs';\nexport function typeFromAST(schema, typeNode) {\n  switch (typeNode.kind) {\n    case Kind.LIST_TYPE: {\n      const innerType = typeFromAST(schema, typeNode.type);\n      return innerType && new GraphQLList(innerType);\n    }\n\n    case Kind.NON_NULL_TYPE: {\n      const innerType = typeFromAST(schema, typeNode.type);\n      return innerType && new GraphQLNonNull(innerType);\n    }\n\n    case Kind.NAMED_TYPE:\n      return schema.getType(typeNode.name.value);\n  }\n}\n"],"names":[],"mappings":";;AAEO,SAAS,YAAY,QAAQ,UAAU;AAC5C,UAAQ,SAAS,MAAI;AAAA,IACnB,KAAK,KAAK,WAAW;AACnB,YAAM,YAAY,YAAY,QAAQ,SAAS,IAAI;AACnD,aAAO,aAAa,IAAI,YAAY,SAAS;AAAA,IAC9C;AAAA,IAED,KAAK,KAAK,eAAe;AACvB,YAAM,YAAY,YAAY,QAAQ,SAAS,IAAI;AACnD,aAAO,aAAa,IAAI,eAAe,SAAS;AAAA,IACjD;AAAA,IAED,KAAK,KAAK;AACR,aAAO,OAAO,QAAQ,SAAS,KAAK,KAAK;AAAA,EAC5C;AACH;"}

package/dist/__node_modules/graphql/utilities/valueFromAST.cjs

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const inspect = require("../jsutils/inspect.cjs");
+const invariant = require("../jsutils/invariant.cjs");
+const keyMap = require("../jsutils/keyMap.cjs");
+const kinds = require("../language/kinds.cjs");
+const definition = require("../type/definition.cjs");
+function valueFromAST(valueNode, type, variables) {
+  if (!valueNode) {
+    return;
+  }
+  if (valueNode.kind === kinds.Kind.VARIABLE) {
+    const variableName = valueNode.name.value;
+    if (variables == null || variables[variableName] === void 0) {
+      return;
+    }
+    const variableValue = variables[variableName];
+    if (variableValue === null && definition.isNonNullType(type)) {
+      return;
+    }
+    return variableValue;
+  }
+  if (definition.isNonNullType(type)) {
+    if (valueNode.kind === kinds.Kind.NULL) {
+      return;
+    }
+    return valueFromAST(valueNode, type.ofType, variables);
+  }
+  if (valueNode.kind === kinds.Kind.NULL) {
+    return null;
+  }
+  if (definition.isListType(type)) {
+    const itemType = type.ofType;
+    if (valueNode.kind === kinds.Kind.LIST) {
+      const coercedValues = [];
+      for (const itemNode of valueNode.values) {
+        if (isMissingVariable(itemNode, variables)) {
+          if (definition.isNonNullType(itemType)) {
+            return;
+          }
+          coercedValues.push(null);
+        } else {
+          const itemValue = valueFromAST(itemNode, itemType, variables);
+          if (itemValue === void 0) {
+            return;
+          }
+          coercedValues.push(itemValue);
+        }
+      }
+      return coercedValues;
+    }
+    const coercedValue = valueFromAST(valueNode, itemType, variables);
+    if (coercedValue === void 0) {
+      return;
+    }
+    return [coercedValue];
+  }
+  if (definition.isInputObjectType(type)) {
+    if (valueNode.kind !== kinds.Kind.OBJECT) {
+      return;
+    }
+    const coercedObj = /* @__PURE__ */ Object.create(null);
+    const fieldNodes = keyMap.keyMap(valueNode.fields, (field) => field.name.value);
+    for (const field of Object.values(type.getFields())) {
+      const fieldNode = fieldNodes[field.name];
+      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
+        if (field.defaultValue !== void 0) {
+          coercedObj[field.name] = field.defaultValue;
+        } else if (definition.isNonNullType(field.type)) {
+          return;
+        }
+        continue;
+      }
+      const fieldValue = valueFromAST(fieldNode.value, field.type, variables);
+      if (fieldValue === void 0) {
+        return;
+      }
+      coercedObj[field.name] = fieldValue;
+    }
+    return coercedObj;
+  }
+  if (definition.isLeafType(type)) {
+    let result;
+    try {
+      result = type.parseLiteral(valueNode, variables);
+    } catch (_error) {
+      return;
+    }
+    if (result === void 0) {
+      return;
+    }
+    return result;
+  }
+  invariant.invariant(false, "Unexpected input type: " + inspect.inspect(type));
+}
+function isMissingVariable(valueNode, variables) {
+  return valueNode.kind === kinds.Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === void 0);
+}
+exports.valueFromAST = valueFromAST;
+//# sourceMappingURL=valueFromAST.cjs.map

package/dist/__node_modules/graphql/utilities/valueFromAST.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromAST.cjs","sources":["../../../../../../node_modules/graphql/utilities/valueFromAST.mjs"],"sourcesContent":["import { inspect } from '../jsutils/inspect.mjs';\nimport { invariant } from '../jsutils/invariant.mjs';\nimport { keyMap } from '../jsutils/keyMap.mjs';\nimport { Kind } from '../language/kinds.mjs';\nimport {\n  isInputObjectType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n} from '../type/definition.mjs';\n/**\n * Produces a JavaScript value given a GraphQL Value AST.\n *\n * A GraphQL type must be provided, which will be used to interpret different\n * GraphQL Value literals.\n *\n * Returns `undefined` when the value could not be validly coerced according to\n * the provided type.\n *\n * | GraphQL Value        | JSON Value    |\n * | -------------------- | ------------- |\n * | Input Object         | Object        |\n * | List                 | Array         |\n * | Boolean              | Boolean       |\n * | String               | String        |\n * | Int / Float          | Number        |\n * | Enum Value           | Unknown       |\n * | NullValue            | null          |\n *\n */\n\nexport function valueFromAST(valueNode, type, variables) {\n  if (!valueNode) {\n    // When there is no node, then there is also no value.\n    // Importantly, this is different from returning the value null.\n    return;\n  }\n\n  if (valueNode.kind === Kind.VARIABLE) {\n    const variableName = valueNode.name.value;\n\n    if (variables == null || variables[variableName] === undefined) {\n      // No valid return value.\n      return;\n    }\n\n    const variableValue = variables[variableName];\n\n    if (variableValue === null && isNonNullType(type)) {\n      return; // Invalid: intentionally return no value.\n    } // Note: This does no further checking that this variable is correct.\n    // This assumes that this query has been validated and the variable\n    // usage here is of the correct type.\n\n    return variableValue;\n  }\n\n  if (isNonNullType(type)) {\n    if (valueNode.kind === Kind.NULL) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return valueFromAST(valueNode, type.ofType, variables);\n  }\n\n  if (valueNode.kind === Kind.NULL) {\n    // This is explicitly returning the value null.\n    return null;\n  }\n\n  if (isListType(type)) {\n    const itemType = type.ofType;\n\n    if (valueNode.kind === Kind.LIST) {\n      const coercedValues = [];\n\n      for (const itemNode of valueNode.values) {\n        if (isMissingVariable(itemNode, variables)) {\n          // If an array contains a missing variable, it is either coerced to\n          // null or if the item type is non-null, it considered invalid.\n          if (isNonNullType(itemType)) {\n            return; // Invalid: intentionally return no value.\n          }\n\n          coercedValues.push(null);\n        } else {\n          const itemValue = valueFromAST(itemNode, itemType, variables);\n\n          if (itemValue === undefined) {\n            return; // Invalid: intentionally return no value.\n          }\n\n          coercedValues.push(itemValue);\n        }\n      }\n\n      return coercedValues;\n    }\n\n    const coercedValue = valueFromAST(valueNode, itemType, variables);\n\n    if (coercedValue === undefined) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return [coercedValue];\n  }\n\n  if (isInputObjectType(type)) {\n    if (valueNode.kind !== Kind.OBJECT) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    const coercedObj = Object.create(null);\n    const fieldNodes = keyMap(valueNode.fields, (field) => field.name.value);\n\n    for (const field of Object.values(type.getFields())) {\n      const fieldNode = fieldNodes[field.name];\n\n      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {\n        if (field.defaultValue !== undefined) {\n          coercedObj[field.name] = field.defaultValue;\n        } else if (isNonNullType(field.type)) {\n          return; // Invalid: intentionally return no value.\n        }\n\n        continue;\n      }\n\n      const fieldValue = valueFromAST(fieldNode.value, field.type, variables);\n\n      if (fieldValue === undefined) {\n        return; // Invalid: intentionally return no value.\n      }\n\n      coercedObj[field.name] = fieldValue;\n    }\n\n    return coercedObj;\n  }\n\n  if (isLeafType(type)) {\n    // Scalars and Enums fulfill parsing a literal value via parseLiteral().\n    // Invalid values represent a failure to parse correctly, in which case\n    // no value is returned.\n    let result;\n\n    try {\n      result = type.parseLiteral(valueNode, variables);\n    } catch (_error) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    if (result === undefined) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return result;\n  }\n  /* c8 ignore next 3 */\n  // Not reachable, all possible input types have been considered.\n\n  false || invariant(false, 'Unexpected input type: ' + inspect(type));\n} // Returns true if the provided valueNode is a variable which is not defined\n// in the set of variables.\n\nfunction isMissingVariable(valueNode, variables) {\n  return (\n    valueNode.kind === Kind.VARIABLE &&\n    (variables == null || variables[valueNode.name.value] === undefined)\n  );\n}\n"],"names":["Kind","isNonNullType","isListType","isInputObjectType","keyMap","isLeafType","invariant","inspect"],"mappings":";;;;;;;AA+BO,SAAS,aAAa,WAAW,MAAM,WAAW;AACvD,MAAI,CAAC,WAAW;AAGd;AAAA,EACD;AAED,MAAI,UAAU,SAASA,MAAI,KAAC,UAAU;AACpC,UAAM,eAAe,UAAU,KAAK;AAEpC,QAAI,aAAa,QAAQ,UAAU,YAAY,MAAM,QAAW;AAE9D;AAAA,IACD;AAED,UAAM,gBAAgB,UAAU,YAAY;AAE5C,QAAI,kBAAkB,QAAQC,WAAa,cAAC,IAAI,GAAG;AACjD;AAAA,IACD;AAID,WAAO;AAAA,EACR;AAED,MAAIA,WAAAA,cAAc,IAAI,GAAG;AACvB,QAAI,UAAU,SAASD,MAAI,KAAC,MAAM;AAChC;AAAA,IACD;AAED,WAAO,aAAa,WAAW,KAAK,QAAQ,SAAS;AAAA,EACtD;AAED,MAAI,UAAU,SAASA,MAAI,KAAC,MAAM;AAEhC,WAAO;AAAA,EACR;AAED,MAAIE,WAAAA,WAAW,IAAI,GAAG;AACpB,UAAM,WAAW,KAAK;AAEtB,QAAI,UAAU,SAASF,MAAI,KAAC,MAAM;AAChC,YAAM,gBAAgB,CAAA;AAEtB,iBAAW,YAAY,UAAU,QAAQ;AACvC,YAAI,kBAAkB,UAAU,SAAS,GAAG;AAG1C,cAAIC,WAAAA,cAAc,QAAQ,GAAG;AAC3B;AAAA,UACD;AAED,wBAAc,KAAK,IAAI;AAAA,QACjC,OAAe;AACL,gBAAM,YAAY,aAAa,UAAU,UAAU,SAAS;AAE5D,cAAI,cAAc,QAAW;AAC3B;AAAA,UACD;AAED,wBAAc,KAAK,SAAS;AAAA,QAC7B;AAAA,MACF;AAED,aAAO;AAAA,IACR;AAED,UAAM,eAAe,aAAa,WAAW,UAAU,SAAS;AAEhE,QAAI,iBAAiB,QAAW;AAC9B;AAAA,IACD;AAED,WAAO,CAAC,YAAY;AAAA,EACrB;AAED,MAAIE,WAAAA,kBAAkB,IAAI,GAAG;AAC3B,QAAI,UAAU,SAASH,MAAI,KAAC,QAAQ;AAClC;AAAA,IACD;AAED,UAAM,aAAa,uBAAO,OAAO,IAAI;AACrC,UAAM,aAAaI,cAAO,UAAU,QAAQ,CAAC,UAAU,MAAM,KAAK,KAAK;AAEvE,eAAW,SAAS,OAAO,OAAO,KAAK,UAAS,CAAE,GAAG;AACnD,YAAM,YAAY,WAAW,MAAM,IAAI;AAEvC,UAAI,CAAC,aAAa,kBAAkB,UAAU,OAAO,SAAS,GAAG;AAC/D,YAAI,MAAM,iBAAiB,QAAW;AACpC,qBAAW,MAAM,IAAI,IAAI,MAAM;AAAA,QAChC,WAAUH,WAAa,cAAC,MAAM,IAAI,GAAG;AACpC;AAAA,QACD;AAED;AAAA,MACD;AAED,YAAM,aAAa,aAAa,UAAU,OAAO,MAAM,MAAM,SAAS;AAEtE,UAAI,eAAe,QAAW;AAC5B;AAAA,MACD;AAED,iBAAW,MAAM,IAAI,IAAI;AAAA,IAC1B;AAED,WAAO;AAAA,EACR;AAED,MAAII,WAAAA,WAAW,IAAI,GAAG;AAIpB,QAAI;AAEJ,QAAI;AACF,eAAS,KAAK,aAAa,WAAW,SAAS;AAAA,IAChD,SAAQ,QAAP;AACA;AAAA,IACD;AAED,QAAI,WAAW,QAAW;AACxB;AAAA,IACD;AAED,WAAO;AAAA,EACR;AAIQC,YAAAA,UAAU,OAAO,4BAA4BC,QAAAA,QAAQ,IAAI,CAAC;AACrE;AAGA,SAAS,kBAAkB,WAAW,WAAW;AAC/C,SACE,UAAU,SAASP,MAAAA,KAAK,aACvB,aAAa,QAAQ,UAAU,UAAU,KAAK,KAAK,MAAM;AAE9D;;"}

package/dist/__node_modules/graphql/utilities/valueFromAST.js

@@ -0,0 +1,100 @@
+import { inspect } from "../jsutils/inspect.js";
+import { invariant } from "../jsutils/invariant.js";
+import { keyMap } from "../jsutils/keyMap.js";
+import { Kind } from "../language/kinds.js";
+import { isNonNullType, isListType, isInputObjectType, isLeafType } from "../type/definition.js";
+function valueFromAST(valueNode, type, variables) {
+  if (!valueNode) {
+    return;
+  }
+  if (valueNode.kind === Kind.VARIABLE) {
+    const variableName = valueNode.name.value;
+    if (variables == null || variables[variableName] === void 0) {
+      return;
+    }
+    const variableValue = variables[variableName];
+    if (variableValue === null && isNonNullType(type)) {
+      return;
+    }
+    return variableValue;
+  }
+  if (isNonNullType(type)) {
+    if (valueNode.kind === Kind.NULL) {
+      return;
+    }
+    return valueFromAST(valueNode, type.ofType, variables);
+  }
+  if (valueNode.kind === Kind.NULL) {
+    return null;
+  }
+  if (isListType(type)) {
+    const itemType = type.ofType;
+    if (valueNode.kind === Kind.LIST) {
+      const coercedValues = [];
+      for (const itemNode of valueNode.values) {
+        if (isMissingVariable(itemNode, variables)) {
+          if (isNonNullType(itemType)) {
+            return;
+          }
+          coercedValues.push(null);
+        } else {
+          const itemValue = valueFromAST(itemNode, itemType, variables);
+          if (itemValue === void 0) {
+            return;
+          }
+          coercedValues.push(itemValue);
+        }
+      }
+      return coercedValues;
+    }
+    const coercedValue = valueFromAST(valueNode, itemType, variables);
+    if (coercedValue === void 0) {
+      return;
+    }
+    return [coercedValue];
+  }
+  if (isInputObjectType(type)) {
+    if (valueNode.kind !== Kind.OBJECT) {
+      return;
+    }
+    const coercedObj = /* @__PURE__ */ Object.create(null);
+    const fieldNodes = keyMap(valueNode.fields, (field) => field.name.value);
+    for (const field of Object.values(type.getFields())) {
+      const fieldNode = fieldNodes[field.name];
+      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {
+        if (field.defaultValue !== void 0) {
+          coercedObj[field.name] = field.defaultValue;
+        } else if (isNonNullType(field.type)) {
+          return;
+        }
+        continue;
+      }
+      const fieldValue = valueFromAST(fieldNode.value, field.type, variables);
+      if (fieldValue === void 0) {
+        return;
+      }
+      coercedObj[field.name] = fieldValue;
+    }
+    return coercedObj;
+  }
+  if (isLeafType(type)) {
+    let result;
+    try {
+      result = type.parseLiteral(valueNode, variables);
+    } catch (_error) {
+      return;
+    }
+    if (result === void 0) {
+      return;
+    }
+    return result;
+  }
+  invariant(false, "Unexpected input type: " + inspect(type));
+}
+function isMissingVariable(valueNode, variables) {
+  return valueNode.kind === Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === void 0);
+}
+export {
+  valueFromAST
+};
+//# sourceMappingURL=valueFromAST.js.map

package/dist/__node_modules/graphql/utilities/valueFromAST.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromAST.js","sources":["../../../../../../node_modules/graphql/utilities/valueFromAST.mjs"],"sourcesContent":["import { inspect } from '../jsutils/inspect.mjs';\nimport { invariant } from '../jsutils/invariant.mjs';\nimport { keyMap } from '../jsutils/keyMap.mjs';\nimport { Kind } from '../language/kinds.mjs';\nimport {\n  isInputObjectType,\n  isLeafType,\n  isListType,\n  isNonNullType,\n} from '../type/definition.mjs';\n/**\n * Produces a JavaScript value given a GraphQL Value AST.\n *\n * A GraphQL type must be provided, which will be used to interpret different\n * GraphQL Value literals.\n *\n * Returns `undefined` when the value could not be validly coerced according to\n * the provided type.\n *\n * | GraphQL Value        | JSON Value    |\n * | -------------------- | ------------- |\n * | Input Object         | Object        |\n * | List                 | Array         |\n * | Boolean              | Boolean       |\n * | String               | String        |\n * | Int / Float          | Number        |\n * | Enum Value           | Unknown       |\n * | NullValue            | null          |\n *\n */\n\nexport function valueFromAST(valueNode, type, variables) {\n  if (!valueNode) {\n    // When there is no node, then there is also no value.\n    // Importantly, this is different from returning the value null.\n    return;\n  }\n\n  if (valueNode.kind === Kind.VARIABLE) {\n    const variableName = valueNode.name.value;\n\n    if (variables == null || variables[variableName] === undefined) {\n      // No valid return value.\n      return;\n    }\n\n    const variableValue = variables[variableName];\n\n    if (variableValue === null && isNonNullType(type)) {\n      return; // Invalid: intentionally return no value.\n    } // Note: This does no further checking that this variable is correct.\n    // This assumes that this query has been validated and the variable\n    // usage here is of the correct type.\n\n    return variableValue;\n  }\n\n  if (isNonNullType(type)) {\n    if (valueNode.kind === Kind.NULL) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return valueFromAST(valueNode, type.ofType, variables);\n  }\n\n  if (valueNode.kind === Kind.NULL) {\n    // This is explicitly returning the value null.\n    return null;\n  }\n\n  if (isListType(type)) {\n    const itemType = type.ofType;\n\n    if (valueNode.kind === Kind.LIST) {\n      const coercedValues = [];\n\n      for (const itemNode of valueNode.values) {\n        if (isMissingVariable(itemNode, variables)) {\n          // If an array contains a missing variable, it is either coerced to\n          // null or if the item type is non-null, it considered invalid.\n          if (isNonNullType(itemType)) {\n            return; // Invalid: intentionally return no value.\n          }\n\n          coercedValues.push(null);\n        } else {\n          const itemValue = valueFromAST(itemNode, itemType, variables);\n\n          if (itemValue === undefined) {\n            return; // Invalid: intentionally return no value.\n          }\n\n          coercedValues.push(itemValue);\n        }\n      }\n\n      return coercedValues;\n    }\n\n    const coercedValue = valueFromAST(valueNode, itemType, variables);\n\n    if (coercedValue === undefined) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return [coercedValue];\n  }\n\n  if (isInputObjectType(type)) {\n    if (valueNode.kind !== Kind.OBJECT) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    const coercedObj = Object.create(null);\n    const fieldNodes = keyMap(valueNode.fields, (field) => field.name.value);\n\n    for (const field of Object.values(type.getFields())) {\n      const fieldNode = fieldNodes[field.name];\n\n      if (!fieldNode || isMissingVariable(fieldNode.value, variables)) {\n        if (field.defaultValue !== undefined) {\n          coercedObj[field.name] = field.defaultValue;\n        } else if (isNonNullType(field.type)) {\n          return; // Invalid: intentionally return no value.\n        }\n\n        continue;\n      }\n\n      const fieldValue = valueFromAST(fieldNode.value, field.type, variables);\n\n      if (fieldValue === undefined) {\n        return; // Invalid: intentionally return no value.\n      }\n\n      coercedObj[field.name] = fieldValue;\n    }\n\n    return coercedObj;\n  }\n\n  if (isLeafType(type)) {\n    // Scalars and Enums fulfill parsing a literal value via parseLiteral().\n    // Invalid values represent a failure to parse correctly, in which case\n    // no value is returned.\n    let result;\n\n    try {\n      result = type.parseLiteral(valueNode, variables);\n    } catch (_error) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    if (result === undefined) {\n      return; // Invalid: intentionally return no value.\n    }\n\n    return result;\n  }\n  /* c8 ignore next 3 */\n  // Not reachable, all possible input types have been considered.\n\n  false || invariant(false, 'Unexpected input type: ' + inspect(type));\n} // Returns true if the provided valueNode is a variable which is not defined\n// in the set of variables.\n\nfunction isMissingVariable(valueNode, variables) {\n  return (\n    valueNode.kind === Kind.VARIABLE &&\n    (variables == null || variables[valueNode.name.value] === undefined)\n  );\n}\n"],"names":[],"mappings":";;;;;AA+BO,SAAS,aAAa,WAAW,MAAM,WAAW;AACvD,MAAI,CAAC,WAAW;AAGd;AAAA,EACD;AAED,MAAI,UAAU,SAAS,KAAK,UAAU;AACpC,UAAM,eAAe,UAAU,KAAK;AAEpC,QAAI,aAAa,QAAQ,UAAU,YAAY,MAAM,QAAW;AAE9D;AAAA,IACD;AAED,UAAM,gBAAgB,UAAU,YAAY;AAE5C,QAAI,kBAAkB,QAAQ,cAAc,IAAI,GAAG;AACjD;AAAA,IACD;AAID,WAAO;AAAA,EACR;AAED,MAAI,cAAc,IAAI,GAAG;AACvB,QAAI,UAAU,SAAS,KAAK,MAAM;AAChC;AAAA,IACD;AAED,WAAO,aAAa,WAAW,KAAK,QAAQ,SAAS;AAAA,EACtD;AAED,MAAI,UAAU,SAAS,KAAK,MAAM;AAEhC,WAAO;AAAA,EACR;AAED,MAAI,WAAW,IAAI,GAAG;AACpB,UAAM,WAAW,KAAK;AAEtB,QAAI,UAAU,SAAS,KAAK,MAAM;AAChC,YAAM,gBAAgB,CAAA;AAEtB,iBAAW,YAAY,UAAU,QAAQ;AACvC,YAAI,kBAAkB,UAAU,SAAS,GAAG;AAG1C,cAAI,cAAc,QAAQ,GAAG;AAC3B;AAAA,UACD;AAED,wBAAc,KAAK,IAAI;AAAA,QACjC,OAAe;AACL,gBAAM,YAAY,aAAa,UAAU,UAAU,SAAS;AAE5D,cAAI,cAAc,QAAW;AAC3B;AAAA,UACD;AAED,wBAAc,KAAK,SAAS;AAAA,QAC7B;AAAA,MACF;AAED,aAAO;AAAA,IACR;AAED,UAAM,eAAe,aAAa,WAAW,UAAU,SAAS;AAEhE,QAAI,iBAAiB,QAAW;AAC9B;AAAA,IACD;AAED,WAAO,CAAC,YAAY;AAAA,EACrB;AAED,MAAI,kBAAkB,IAAI,GAAG;AAC3B,QAAI,UAAU,SAAS,KAAK,QAAQ;AAClC;AAAA,IACD;AAED,UAAM,aAAa,uBAAO,OAAO,IAAI;AACrC,UAAM,aAAa,OAAO,UAAU,QAAQ,CAAC,UAAU,MAAM,KAAK,KAAK;AAEvE,eAAW,SAAS,OAAO,OAAO,KAAK,UAAS,CAAE,GAAG;AACnD,YAAM,YAAY,WAAW,MAAM,IAAI;AAEvC,UAAI,CAAC,aAAa,kBAAkB,UAAU,OAAO,SAAS,GAAG;AAC/D,YAAI,MAAM,iBAAiB,QAAW;AACpC,qBAAW,MAAM,IAAI,IAAI,MAAM;AAAA,QAChC,WAAU,cAAc,MAAM,IAAI,GAAG;AACpC;AAAA,QACD;AAED;AAAA,MACD;AAED,YAAM,aAAa,aAAa,UAAU,OAAO,MAAM,MAAM,SAAS;AAEtE,UAAI,eAAe,QAAW;AAC5B;AAAA,MACD;AAED,iBAAW,MAAM,IAAI,IAAI;AAAA,IAC1B;AAED,WAAO;AAAA,EACR;AAED,MAAI,WAAW,IAAI,GAAG;AAIpB,QAAI;AAEJ,QAAI;AACF,eAAS,KAAK,aAAa,WAAW,SAAS;AAAA,IAChD,SAAQ,QAAP;AACA;AAAA,IACD;AAED,QAAI,WAAW,QAAW;AACxB;AAAA,IACD;AAED,WAAO;AAAA,EACR;AAIQ,YAAU,OAAO,4BAA4B,QAAQ,IAAI,CAAC;AACrE;AAGA,SAAS,kBAAkB,WAAW,WAAW;AAC/C,SACE,UAAU,SAAS,KAAK,aACvB,aAAa,QAAQ,UAAU,UAAU,KAAK,KAAK,MAAM;AAE9D;"}

package/dist/__node_modules/graphql/utilities/valueFromASTUntyped.cjs

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const keyValMap = require("../jsutils/keyValMap.cjs");
+const kinds = require("../language/kinds.cjs");
+function valueFromASTUntyped(valueNode, variables) {
+  switch (valueNode.kind) {
+    case kinds.Kind.NULL:
+      return null;
+    case kinds.Kind.INT:
+      return parseInt(valueNode.value, 10);
+    case kinds.Kind.FLOAT:
+      return parseFloat(valueNode.value);
+    case kinds.Kind.STRING:
+    case kinds.Kind.ENUM:
+    case kinds.Kind.BOOLEAN:
+      return valueNode.value;
+    case kinds.Kind.LIST:
+      return valueNode.values.map(
+        (node) => valueFromASTUntyped(node, variables)
+      );
+    case kinds.Kind.OBJECT:
+      return keyValMap.keyValMap(
+        valueNode.fields,
+        (field) => field.name.value,
+        (field) => valueFromASTUntyped(field.value, variables)
+      );
+    case kinds.Kind.VARIABLE:
+      return variables === null || variables === void 0 ? void 0 : variables[valueNode.name.value];
+  }
+}
+exports.valueFromASTUntyped = valueFromASTUntyped;
+//# sourceMappingURL=valueFromASTUntyped.cjs.map

package/dist/__node_modules/graphql/utilities/valueFromASTUntyped.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromASTUntyped.cjs","sources":["../../../../../../node_modules/graphql/utilities/valueFromASTUntyped.mjs"],"sourcesContent":["import { keyValMap } from '../jsutils/keyValMap.mjs';\nimport { Kind } from '../language/kinds.mjs';\n/**\n * Produces a JavaScript value given a GraphQL Value AST.\n *\n * Unlike `valueFromAST()`, no type is provided. The resulting JavaScript value\n * will reflect the provided GraphQL value AST.\n *\n * | GraphQL Value        | JavaScript Value |\n * | -------------------- | ---------------- |\n * | Input Object         | Object           |\n * | List                 | Array            |\n * | Boolean              | Boolean          |\n * | String / Enum        | String           |\n * | Int / Float          | Number           |\n * | Null                 | null             |\n *\n */\n\nexport function valueFromASTUntyped(valueNode, variables) {\n  switch (valueNode.kind) {\n    case Kind.NULL:\n      return null;\n\n    case Kind.INT:\n      return parseInt(valueNode.value, 10);\n\n    case Kind.FLOAT:\n      return parseFloat(valueNode.value);\n\n    case Kind.STRING:\n    case Kind.ENUM:\n    case Kind.BOOLEAN:\n      return valueNode.value;\n\n    case Kind.LIST:\n      return valueNode.values.map((node) =>\n        valueFromASTUntyped(node, variables),\n      );\n\n    case Kind.OBJECT:\n      return keyValMap(\n        valueNode.fields,\n        (field) => field.name.value,\n        (field) => valueFromASTUntyped(field.value, variables),\n      );\n\n    case Kind.VARIABLE:\n      return variables === null || variables === void 0\n        ? void 0\n        : variables[valueNode.name.value];\n  }\n}\n"],"names":["Kind","keyValMap"],"mappings":";;;;AAmBO,SAAS,oBAAoB,WAAW,WAAW;AACxD,UAAQ,UAAU,MAAI;AAAA,IACpB,KAAKA,MAAI,KAAC;AACR,aAAO;AAAA,IAET,KAAKA,MAAI,KAAC;AACR,aAAO,SAAS,UAAU,OAAO,EAAE;AAAA,IAErC,KAAKA,MAAI,KAAC;AACR,aAAO,WAAW,UAAU,KAAK;AAAA,IAEnC,KAAKA,MAAAA,KAAK;AAAA,IACV,KAAKA,MAAAA,KAAK;AAAA,IACV,KAAKA,MAAI,KAAC;AACR,aAAO,UAAU;AAAA,IAEnB,KAAKA,MAAI,KAAC;AACR,aAAO,UAAU,OAAO;AAAA,QAAI,CAAC,SAC3B,oBAAoB,MAAM,SAAS;AAAA,MAC3C;AAAA,IAEI,KAAKA,MAAI,KAAC;AACR,aAAOC,UAAS;AAAA,QACd,UAAU;AAAA,QACV,CAAC,UAAU,MAAM,KAAK;AAAA,QACtB,CAAC,UAAU,oBAAoB,MAAM,OAAO,SAAS;AAAA,MAC7D;AAAA,IAEI,KAAKD,MAAI,KAAC;AACR,aAAO,cAAc,QAAQ,cAAc,SACvC,SACA,UAAU,UAAU,KAAK,KAAK;AAAA,EACrC;AACH;;"}

package/dist/__node_modules/graphql/utilities/valueFromASTUntyped.js

@@ -0,0 +1,32 @@
+import { keyValMap } from "../jsutils/keyValMap.js";
+import { Kind } from "../language/kinds.js";
+function valueFromASTUntyped(valueNode, variables) {
+  switch (valueNode.kind) {
+    case Kind.NULL:
+      return null;
+    case Kind.INT:
+      return parseInt(valueNode.value, 10);
+    case Kind.FLOAT:
+      return parseFloat(valueNode.value);
+    case Kind.STRING:
+    case Kind.ENUM:
+    case Kind.BOOLEAN:
+      return valueNode.value;
+    case Kind.LIST:
+      return valueNode.values.map(
+        (node) => valueFromASTUntyped(node, variables)
+      );
+    case Kind.OBJECT:
+      return keyValMap(
+        valueNode.fields,
+        (field) => field.name.value,
+        (field) => valueFromASTUntyped(field.value, variables)
+      );
+    case Kind.VARIABLE:
+      return variables === null || variables === void 0 ? void 0 : variables[valueNode.name.value];
+  }
+}
+export {
+  valueFromASTUntyped
+};
+//# sourceMappingURL=valueFromASTUntyped.js.map

package/dist/__node_modules/graphql/utilities/valueFromASTUntyped.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromASTUntyped.js","sources":["../../../../../../node_modules/graphql/utilities/valueFromASTUntyped.mjs"],"sourcesContent":["import { keyValMap } from '../jsutils/keyValMap.mjs';\nimport { Kind } from '../language/kinds.mjs';\n/**\n * Produces a JavaScript value given a GraphQL Value AST.\n *\n * Unlike `valueFromAST()`, no type is provided. The resulting JavaScript value\n * will reflect the provided GraphQL value AST.\n *\n * | GraphQL Value        | JavaScript Value |\n * | -------------------- | ---------------- |\n * | Input Object         | Object           |\n * | List                 | Array            |\n * | Boolean              | Boolean          |\n * | String / Enum        | String           |\n * | Int / Float          | Number           |\n * | Null                 | null             |\n *\n */\n\nexport function valueFromASTUntyped(valueNode, variables) {\n  switch (valueNode.kind) {\n    case Kind.NULL:\n      return null;\n\n    case Kind.INT:\n      return parseInt(valueNode.value, 10);\n\n    case Kind.FLOAT:\n      return parseFloat(valueNode.value);\n\n    case Kind.STRING:\n    case Kind.ENUM:\n    case Kind.BOOLEAN:\n      return valueNode.value;\n\n    case Kind.LIST:\n      return valueNode.values.map((node) =>\n        valueFromASTUntyped(node, variables),\n      );\n\n    case Kind.OBJECT:\n      return keyValMap(\n        valueNode.fields,\n        (field) => field.name.value,\n        (field) => valueFromASTUntyped(field.value, variables),\n      );\n\n    case Kind.VARIABLE:\n      return variables === null || variables === void 0\n        ? void 0\n        : variables[valueNode.name.value];\n  }\n}\n"],"names":[],"mappings":";;AAmBO,SAAS,oBAAoB,WAAW,WAAW;AACxD,UAAQ,UAAU,MAAI;AAAA,IACpB,KAAK,KAAK;AACR,aAAO;AAAA,IAET,KAAK,KAAK;AACR,aAAO,SAAS,UAAU,OAAO,EAAE;AAAA,IAErC,KAAK,KAAK;AACR,aAAO,WAAW,UAAU,KAAK;AAAA,IAEnC,KAAK,KAAK;AAAA,IACV,KAAK,KAAK;AAAA,IACV,KAAK,KAAK;AACR,aAAO,UAAU;AAAA,IAEnB,KAAK,KAAK;AACR,aAAO,UAAU,OAAO;AAAA,QAAI,CAAC,SAC3B,oBAAoB,MAAM,SAAS;AAAA,MAC3C;AAAA,IAEI,KAAK,KAAK;AACR,aAAO;AAAA,QACL,UAAU;AAAA,QACV,CAAC,UAAU,MAAM,KAAK;AAAA,QACtB,CAAC,UAAU,oBAAoB,MAAM,OAAO,SAAS;AAAA,MAC7D;AAAA,IAEI,KAAK,KAAK;AACR,aAAO,cAAc,QAAQ,cAAc,SACvC,SACA,UAAU,UAAU,KAAK,KAAK;AAAA,EACrC;AACH;"}