@0no-co/graphql.web 0.0.0-canary-20230320141923

package/dist/graphql.web.js

@@ -0,0 +1,873 @@
+Object.defineProperty(exports, "__esModule", {
+  value: !0
+});
+
+class GraphQLError extends Error {
+  constructor(e, r, i, n, t, a, o) {
+    super(e);
+    this.name = "GraphQLError";
+    this.message = e;
+    if (t) {
+      this.path = t;
+    }
+    if (r) {
+      this.nodes = Array.isArray(r) ? r : [ r ];
+    }
+    if (i) {
+      this.source = i;
+    }
+    if (n) {
+      this.positions = n;
+    }
+    if (a) {
+      this.originalError = a;
+    }
+    if (!o && a) {
+      var l = a.extensions;
+      if (l && "object" == typeof l) {
+        l;
+      }
+    }
+    this.extensions = o || {};
+  }
+  toJSON() {
+    return {
+      ...this
+    };
+  }
+  toString() {
+    return this.message;
+  }
+  get [Symbol.toStringTag]() {
+    return "GraphQLError";
+  }
+}
+
+var e;
+
+var r;
+
+function error(e) {
+  return new GraphQLError(`Syntax Error: Unexpected token at ${r} in ${e}`);
+}
+
+function advance(i) {
+  i.lastIndex = r;
+  if (i.test(e)) {
+    return e.slice(r, r = i.lastIndex);
+  }
+}
+
+var i = / +(?=[^\s])/y;
+
+function blockString(e) {
+  var r = "";
+  var n = 0;
+  var t = 0;
+  var a = -1;
+  var o = e.split("\n");
+  for (var l = 0; l < o.length; l++) {
+    i.lastIndex = 0;
+    if (i.test(o[l])) {
+      if (l && (!n || i.lastIndex < n)) {
+        n = i.lastIndex;
+      }
+      t = t || l;
+      a = l;
+    }
+  }
+  for (var u = t; u <= a; u++) {
+    if (u !== t) {
+      r += "\n";
+    }
+    r += o[u].slice(n).replace(/\\"""/g, '"""');
+  }
+  return r;
+}
+
+var n = /(?:[\s,]*|#[^\n\r]*)*/y;
+
+function ignored() {
+  n.lastIndex = r;
+  n.test(e);
+  r = n.lastIndex;
+}
+
+var t = /[_\w][_\d\w]*/y;
+
+function name() {
+  var e;
+  if (e = advance(t)) {
+    return {
+      kind: "Name",
+      value: e
+    };
+  }
+}
+
+var a = /null|true|false/y;
+
+var o = /\$[_\w][_\d\w]*/y;
+
+var l = /[-]?\d+/y;
+
+var u = /(?:[-]?\d+)?(?:\.\d+)(?:[eE][+-]?\d+)?/y;
+
+var s = /\\/g;
+
+var d = /"""(?:[\s\S]+(?="""))?"""/y;
+
+var v = /"(?:[^"\r\n]+)?"/y;
+
+function value(i) {
+  var n;
+  var c;
+  if (c = advance(a)) {
+    n = "null" === c ? {
+      kind: "NullValue"
+    } : {
+      kind: "BooleanValue",
+      value: "true" === c
+    };
+  } else if (!i && (c = advance(o))) {
+    n = {
+      kind: "Variable",
+      name: {
+        kind: "Name",
+        value: c.slice(1)
+      }
+    };
+  } else if (c = advance(u)) {
+    n = {
+      kind: "FloatValue",
+      value: c
+    };
+  } else if (c = advance(l)) {
+    n = {
+      kind: "IntValue",
+      value: c
+    };
+  } else if (c = advance(t)) {
+    n = {
+      kind: "EnumValue",
+      value: c
+    };
+  } else if (c = advance(d)) {
+    n = {
+      kind: "StringValue",
+      value: blockString(c.slice(3, -3)),
+      block: !0
+    };
+  } else if (c = advance(v)) {
+    n = {
+      kind: "StringValue",
+      value: s.test(c) ? JSON.parse(c) : c.slice(1, -1),
+      block: !1
+    };
+  } else if (n = function list(i) {
+    var n;
+    if (91 === e.charCodeAt(r)) {
+      r++;
+      ignored();
+      var t = [];
+      while (n = value(i)) {
+        t.push(n);
+      }
+      if (93 !== e.charCodeAt(r++)) {
+        throw error("ListValue");
+      }
+      ignored();
+      return {
+        kind: "ListValue",
+        values: t
+      };
+    }
+  }(i) || function object(i) {
+    if (123 === e.charCodeAt(r)) {
+      r++;
+      ignored();
+      var n = [];
+      var t;
+      while (t = name()) {
+        ignored();
+        if (58 !== e.charCodeAt(r++)) {
+          throw error("ObjectField");
+        }
+        ignored();
+        var a = value(i);
+        if (!a) {
+          throw error("ObjectField");
+        }
+        n.push({
+          kind: "ObjectField",
+          name: t,
+          value: a
+        });
+      }
+      if (125 !== e.charCodeAt(r++)) {
+        throw error("ObjectValue");
+      }
+      ignored();
+      return {
+        kind: "ObjectValue",
+        fields: n
+      };
+    }
+  }(i)) {
+    return n;
+  }
+  ignored();
+  return n;
+}
+
+function arguments_(i) {
+  var n = [];
+  ignored();
+  if (40 === e.charCodeAt(r)) {
+    r++;
+    ignored();
+    var t;
+    while (t = name()) {
+      ignored();
+      if (58 !== e.charCodeAt(r++)) {
+        throw error("Argument");
+      }
+      ignored();
+      var a = value(i);
+      if (!a) {
+        throw error("Argument");
+      }
+      n.push({
+        kind: "Argument",
+        name: t,
+        value: a
+      });
+    }
+    if (!n.length || 41 !== e.charCodeAt(r++)) {
+      throw error("Argument");
+    }
+    ignored();
+  }
+  return n;
+}
+
+function directives(i) {
+  var n = [];
+  ignored();
+  while (64 === e.charCodeAt(r)) {
+    r++;
+    var t = name();
+    if (!t) {
+      throw error("Directive");
+    }
+    ignored();
+    n.push({
+      kind: "Directive",
+      name: t,
+      arguments: arguments_(i)
+    });
+  }
+  return n;
+}
+
+function field() {
+  ignored();
+  var i = name();
+  if (i) {
+    ignored();
+    var n;
+    if (58 === e.charCodeAt(r)) {
+      r++;
+      ignored();
+      n = i;
+      if (!(i = name())) {
+        throw error("Field");
+      }
+      ignored();
+    }
+    return {
+      kind: "Field",
+      alias: n,
+      name: i,
+      arguments: arguments_(!1),
+      directives: directives(!1),
+      selectionSet: selectionSet()
+    };
+  }
+}
+
+function type() {
+  var i;
+  ignored();
+  if (91 === e.charCodeAt(r)) {
+    r++;
+    ignored();
+    var n = type();
+    if (!n || 93 !== e.charCodeAt(r++)) {
+      throw error("ListType");
+    }
+    i = {
+      kind: "ListType",
+      type: n
+    };
+  } else if (i = name()) {
+    i = {
+      kind: "NamedType",
+      name: i
+    };
+  } else {
+    throw error("NamedType");
+  }
+  ignored();
+  if (33 === e.charCodeAt(r)) {
+    r++;
+    ignored();
+    return {
+      kind: "NonNullType",
+      type: i
+    };
+  } else {
+    return i;
+  }
+}
+
+var c = /on/y;
+
+function typeCondition() {
+  if (advance(c)) {
+    ignored();
+    var e = name();
+    if (!e) {
+      throw error("NamedType");
+    }
+    ignored();
+    return {
+      kind: "NamedType",
+      name: e
+    };
+  }
+}
+
+var f = /\.\.\./y;
+
+function fragmentSpread() {
+  ignored();
+  if (advance(f)) {
+    ignored();
+    var e = r;
+    var i;
+    if ((i = name()) && "on" !== i.value) {
+      return {
+        kind: "FragmentSpread",
+        name: i,
+        directives: directives(!1)
+      };
+    } else {
+      r = e;
+      var n = typeCondition();
+      var t = directives(!1);
+      var a = selectionSet();
+      if (!a) {
+        throw error("InlineFragment");
+      }
+      return {
+        kind: "InlineFragment",
+        typeCondition: n,
+        directives: t,
+        selectionSet: a
+      };
+    }
+  }
+}
+
+function selectionSet() {
+  var i;
+  ignored();
+  if (123 === e.charCodeAt(r)) {
+    r++;
+    ignored();
+    var n = [];
+    while (i = fragmentSpread() || field()) {
+      n.push(i);
+    }
+    if (!n.length || 125 !== e.charCodeAt(r++)) {
+      throw error("SelectionSet");
+    }
+    ignored();
+    return {
+      kind: "SelectionSet",
+      selections: n
+    };
+  }
+}
+
+var p = /fragment/y;
+
+function fragmentDefinition() {
+  if (advance(p)) {
+    ignored();
+    var e = name();
+    if (!e) {
+      throw error("FragmentDefinition");
+    }
+    ignored();
+    var r = typeCondition();
+    if (!r) {
+      throw error("FragmentDefinition");
+    }
+    var i = directives(!1);
+    var n = selectionSet();
+    if (!n) {
+      throw error("FragmentDefinition");
+    }
+    return {
+      kind: "FragmentDefinition",
+      name: e,
+      typeCondition: r,
+      directives: i,
+      selectionSet: n
+    };
+  }
+}
+
+var m = /query|mutation|subscription/y;
+
+function operationDefinition() {
+  var i;
+  var n;
+  var t = [];
+  var a = [];
+  if (i = advance(m)) {
+    ignored();
+    n = name();
+    t = function variableDefinitions() {
+      var i;
+      var n = [];
+      ignored();
+      if (40 === e.charCodeAt(r)) {
+        r++;
+        ignored();
+        while (i = advance(o)) {
+          ignored();
+          if (58 !== e.charCodeAt(r++)) {
+            throw error("VariableDefinition");
+          }
+          var t = type();
+          if (!t) {
+            throw error("VariableDefinition");
+          }
+          var a = void 0;
+          if (61 === e.charCodeAt(r)) {
+            r++;
+            ignored();
+            if (!(a = value(!0))) {
+              throw error("VariableDefinition");
+            }
+          }
+          ignored();
+          n.push({
+            kind: "VariableDefinition",
+            variable: {
+              kind: "Variable",
+              name: {
+                kind: "Name",
+                value: i.slice(1)
+              }
+            },
+            type: t,
+            defaultValue: a,
+            directives: directives(!0)
+          });
+        }
+        if (41 !== e.charCodeAt(r++)) {
+          throw error("VariableDefinition");
+        }
+        ignored();
+      }
+      return n;
+    }();
+    a = directives(!1);
+  }
+  var l = selectionSet();
+  if (l) {
+    return {
+      kind: "OperationDefinition",
+      operation: i || "query",
+      name: n,
+      variableDefinitions: t,
+      directives: a,
+      selectionSet: l
+    };
+  }
+}
+
+var g = {};
+
+function printString(e) {
+  return JSON.stringify(e);
+}
+
+function printBlockString(e) {
+  return '"""\n' + e.replace(/"""/g, '\\"""') + '\n"""';
+}
+
+var hasItems = e => !(!e || !e.length);
+
+var h = 80;
+
+function valueFromASTUntyped(e, r) {
+  switch (e.kind) {
+   case "NullValue":
+    return null;
+
+   case "IntValue":
+    return parseInt(e.value, 10);
+
+   case "FloatValue":
+    return parseFloat(e.value);
+
+   case "StringValue":
+   case "EnumValue":
+   case "BooleanValue":
+    return e.value;
+
+   case "ListValue":
+    var i = [];
+    for (var n = 0, t = e.values; n < t.length; n += 1) {
+      i.push(valueFromASTUntyped(t[n], r));
+    }
+    return i;
+
+   case "ObjectValue":
+    var a = Object.create(null);
+    for (var o = 0, l = e.fields; o < l.length; o += 1) {
+      var u = l[o];
+      a[u.name.value] = valueFromASTUntyped(u.value, r);
+    }
+    return a;
+
+   case "Variable":
+    return r && r[e.name.value];
+  }
+}
+
+exports.BREAK = g;
+
+exports.GraphQLError = GraphQLError;
+
+exports.Kind = {
+  NAME: "Name",
+  DOCUMENT: "Document",
+  OPERATION_DEFINITION: "OperationDefinition",
+  VARIABLE_DEFINITION: "VariableDefinition",
+  SELECTION_SET: "SelectionSet",
+  FIELD: "Field",
+  ARGUMENT: "Argument",
+  FRAGMENT_SPREAD: "FragmentSpread",
+  INLINE_FRAGMENT: "InlineFragment",
+  FRAGMENT_DEFINITION: "FragmentDefinition",
+  VARIABLE: "Variable",
+  OBJECT: "ObjectValue",
+  OBJECT_FIELD: "ObjectField",
+  DIRECTIVE: "Directive",
+  NAMED_TYPE: "NamedType",
+  LIST_TYPE: "ListType",
+  NON_NULL_TYPE: "NonNullType"
+};
+
+exports.OperationTypeNode = {
+  QUERY: "query",
+  MUTATION: "mutation",
+  SUBSCRIPTION: "subscription"
+};
+
+exports.blockString = blockString;
+
+exports.parse = function parse(i, n) {
+  e = "string" == typeof i.body ? i.body : i;
+  r = 0;
+  return function document() {
+    var i;
+    ignored();
+    var n = [];
+    while (i = fragmentDefinition() || operationDefinition()) {
+      n.push(i);
+    }
+    if (r !== e.length) {
+      throw error("Document");
+    }
+    return {
+      kind: "Document",
+      definitions: n
+    };
+  }();
+};
+
+exports.parseType = function parseType(i, n) {
+  e = "string" == typeof i.body ? i.body : i;
+  r = 0;
+  var t = type();
+  if (!t) {
+    throw error("TypeNode");
+  }
+  return t;
+};
+
+exports.parseValue = function parseValue(i, n) {
+  e = "string" == typeof i.body ? i.body : i;
+  r = 0;
+  ignored();
+  var t = value(!1);
+  if (!t) {
+    throw error("ValueNode");
+  }
+  return t;
+};
+
+exports.print = function print(e) {
+  var r;
+  switch (e.kind) {
+   case "OperationDefinition":
+    if ("query" === e.operation && !e.name && !hasItems(e.variableDefinitions) && !hasItems(e.directives)) {
+      return print(e.selectionSet);
+    }
+    r = e.operation;
+    if (e.name) {
+      r += " " + e.name.value;
+    }
+    if (hasItems(e.variableDefinitions)) {
+      if (!e.name) {
+        r += " ";
+      }
+      r += "(" + e.variableDefinitions.map(print).join(", ") + ")";
+    }
+    if (hasItems(e.directives)) {
+      r += " " + e.directives.map(print).join(" ");
+    }
+    return r + " " + print(e.selectionSet);
+
+   case "VariableDefinition":
+    r = print(e.variable) + ": " + print(e.type);
+    if (e.defaultValue) {
+      r += " = " + print(e.defaultValue);
+    }
+    if (hasItems(e.directives)) {
+      r += " " + e.directives.map(print).join(" ");
+    }
+    return r;
+
+   case "Field":
+    r = (e.alias ? print(e.alias) + ": " : "") + e.name.value;
+    if (hasItems(e.arguments)) {
+      var i = e.arguments.map(print);
+      var n = r + "(" + i.join(", ") + ")";
+      r = n.length > h ? r + "(\n  " + i.join("\n").replace(/\n/g, "\n  ") + "\n)" : n;
+    }
+    if (hasItems(e.directives)) {
+      r += " " + e.directives.map(print).join(" ");
+    }
+    return e.selectionSet ? r + " " + print(e.selectionSet) : r;
+
+   case "StringValue":
+    return e.block ? printBlockString(e.value) : printString(e.value);
+
+   case "BooleanValue":
+    return "" + e.value;
+
+   case "NullValue":
+    return "null";
+
+   case "IntValue":
+   case "FloatValue":
+   case "EnumValue":
+   case "Name":
+    return e.value;
+
+   case "ListValue":
+    return "[" + e.values.map(print).join(", ") + "]";
+
+   case "ObjectValue":
+    return "{" + e.fields.map(print).join(", ") + "}";
+
+   case "ObjectField":
+   case "Argument":
+    return e.name.value + ": " + print(e.value);
+
+   case "Variable":
+    return "$" + e.name.value;
+
+   case "Document":
+    return hasItems(e.definitions) ? e.definitions.map(print).join("\n\n") : "";
+
+   case "SelectionSet":
+    return "{\n  " + e.selections.map(print).join("\n").replace(/\n/g, "\n  ") + "\n}";
+
+   case "FragmentSpread":
+    r = "..." + e.name.value;
+    if (hasItems(e.directives)) {
+      r += " " + e.directives.map(print).join(" ");
+    }
+    return r;
+
+   case "InlineFragment":
+    r = "...";
+    if (e.typeCondition) {
+      r += " on " + e.typeCondition.name.value;
+    }
+    if (hasItems(e.directives)) {
+      r += " " + e.directives.map(print).join(" ");
+    }
+    return r + " " + print(e.selectionSet);
+
+   case "FragmentDefinition":
+    r = "fragment " + e.name.value;
+    r += " on " + e.typeCondition.name.value;
+    if (hasItems(e.directives)) {
+      r += " " + e.directives.map(print).join(" ");
+    }
+    return r + " " + print(e.selectionSet);
+
+   case "Directive":
+    r = "@" + e.name.value;
+    if (hasItems(e.arguments)) {
+      r += "(" + e.arguments.map(print).join(", ") + ")";
+    }
+    return r;
+
+   case "NamedType":
+    return e.name.value;
+
+   case "ListType":
+    return "[" + print(e.type) + "]";
+
+   case "NonNullType":
+    return print(e.type) + "!";
+
+   default:
+    return "";
+  }
+};
+
+exports.printBlockString = printBlockString;
+
+exports.printString = printString;
+
+exports.valueFromASTUntyped = valueFromASTUntyped;
+
+exports.valueFromTypeNode = function valueFromTypeNode(e, r, i) {
+  if ("Variable" === e.kind) {
+    return i ? valueFromTypeNode(i[e.name.value], r, i) : void 0;
+  } else if ("NonNullType" === r.kind) {
+    return "NullValue" !== e.kind ? valueFromTypeNode(e, r, i) : void 0;
+  } else if ("NullValue" === e.kind) {
+    return null;
+  } else if ("ListType" === r.kind) {
+    if ("ListValue" === e.kind) {
+      var n = [];
+      for (var t = 0, a = e.values; t < a.length; t += 1) {
+        var o = valueFromTypeNode(a[t], r.type, i);
+        if (void 0 === o) {
+          return;
+        } else {
+          n.push(o);
+        }
+      }
+      return n;
+    }
+  } else if ("NamedType" === r.kind) {
+    switch (r.name.value) {
+     case "Int":
+     case "Float":
+     case "String":
+     case "Bool":
+      return r.name.value + "Value" === e.kind ? valueFromASTUntyped(e, i) : void 0;
+
+     default:
+      return valueFromASTUntyped(e, i);
+    }
+  }
+};
+
+exports.visit = function visit(e, r) {
+  var i = [];
+  var n = [];
+  try {
+    var t = function traverse(e, t, a) {
+      var o = !1;
+      var l = r[e.kind] && r[e.kind].enter || r[e.kind];
+      var u = l && l.call(r, e, t, a, n, i);
+      if (!1 === u) {
+        return e;
+      } else if (null === u) {
+        return null;
+      } else if (u === g) {
+        throw g;
+      } else if (u && "string" == typeof u.kind) {
+        o = u !== e;
+        e = u;
+      }
+      if (a) {
+        i.push(a);
+      }
+      var s;
+      var d = {
+        ...e
+      };
+      for (var v in e) {
+        n.push(v);
+        var c = e[v];
+        if (Array.isArray(c)) {
+          var f = [];
+          for (var p = 0; p < c.length; p++) {
+            if (null != c[p] && "string" == typeof c[p].kind) {
+              i.push(e);
+              n.push(p);
+              s = traverse(c[p], p, c);
+              n.pop();
+              i.pop();
+              if (void 0 === s) {
+                f.push(c[p]);
+              } else if (null === s) {
+                o = !0;
+              } else {
+                o = o || s !== c[p];
+                f.push(s);
+              }
+            }
+          }
+          c = f;
+        } else if (null != c && "string" == typeof c.kind) {
+          if (void 0 !== (s = traverse(c, v, e))) {
+            o = o || c !== s;
+            c = s;
+          }
+        }
+        n.pop();
+        if (o) {
+          d[v] = c;
+        }
+      }
+      if (a) {
+        i.pop();
+      }
+      var m = r[e.kind] && r[e.kind].leave;
+      var h = m && m.call(r, e, t, a, n, i);
+      if (h === g) {
+        throw g;
+      } else if (void 0 !== h) {
+        return h;
+      } else if (void 0 !== u) {
+        return o ? d : u;
+      } else {
+        return o ? d : e;
+      }
+    }(e);
+    return void 0 !== t && !1 !== t ? t : e;
+  } catch (r) {
+    if (r !== g) {
+      throw r;
+    }
+    return e;
+  }
+};
+//# sourceMappingURL=graphql.web.js.map