@0no-co/graphql.web 0.1.0 → 0.1.1

package/dist/graphql.web.mjs

@@ -0,0 +1,786 @@
+var e;
+
+!function(e) {
+  e.QUERY = "query";
+  e.MUTATION = "mutation";
+  e.SUBSCRIPTION = "subscription";
+}(e || (e = {}));
+
+var r;
+
+!function(e) {
+  e.NAME = "Name";
+  e.DOCUMENT = "Document";
+  e.OPERATION_DEFINITION = "OperationDefinition";
+  e.VARIABLE_DEFINITION = "VariableDefinition";
+  e.SELECTION_SET = "SelectionSet";
+  e.FIELD = "Field";
+  e.ARGUMENT = "Argument";
+  e.FRAGMENT_SPREAD = "FragmentSpread";
+  e.INLINE_FRAGMENT = "InlineFragment";
+  e.FRAGMENT_DEFINITION = "FragmentDefinition";
+  e.VARIABLE = "Variable";
+  e.INT = "IntValue";
+  e.FLOAT = "FloatValue";
+  e.STRING = "StringValue";
+  e.BOOLEAN = "BooleanValue";
+  e.NULL = "NullValue";
+  e.ENUM = "EnumValue";
+  e.LIST = "ListValue";
+  e.OBJECT = "ObjectValue";
+  e.OBJECT_FIELD = "ObjectField";
+  e.DIRECTIVE = "Directive";
+  e.NAMED_TYPE = "NamedType";
+  e.LIST_TYPE = "ListType";
+  e.NON_NULL_TYPE = "NonNullType";
+}(r || (r = {}));
+
+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 s = a.extensions;
+      if (s && "object" == typeof s) {
+        s;
+      }
+    }
+    this.extensions = o || {};
+  }
+  toJSON() {
+    return {
+      ...this
+    };
+  }
+  toString() {
+    return this.message;
+  }
+}
+
+var i;
+
+var n;
+
+function error(e) {
+  return new GraphQLError(`Syntax Error: Unexpected token at ${n} in ${e}`);
+}
+
+function advance(e) {
+  e.lastIndex = n;
+  if (e.test(i)) {
+    return i.slice(n, n = e.lastIndex);
+  }
+}
+
+var t = / +(?=[^\s])/y;
+
+function blockString(e) {
+  var r = "";
+  var i = 0;
+  var n = 0;
+  var a = -1;
+  var o = e.split("\n");
+  for (var s = 0; s < o.length; s++) {
+    t.lastIndex = 0;
+    if (t.test(o[s])) {
+      if (s && (!i || t.lastIndex < i)) {
+        i = t.lastIndex;
+      }
+      n = n || s;
+      a = s;
+    }
+  }
+  for (var d = n; d <= a; d++) {
+    if (d !== n) {
+      r += "\n";
+    }
+    r += o[d].slice(i);
+  }
+  return r;
+}
+
+var a = /(?:[\s,]*|#[^\n\r]*)*/y;
+
+function ignored() {
+  a.lastIndex = n;
+  a.test(i);
+  n = a.lastIndex;
+}
+
+var o = /[_\w][_\d\w]*/y;
+
+function name() {
+  var e;
+  if (e = advance(o)) {
+    return {
+      kind: r.NAME,
+      value: e
+    };
+  }
+}
+
+var s = /null/y;
+
+var d = /true|false/y;
+
+var u = /\$[_\w][_\d\w]*/y;
+
+var v = /[-]?\d+/y;
+
+var l = /[-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/y;
+
+var c = /\\/g;
+
+var f = /"""(?:[\s\S]+(?="""))?"""/y;
+
+var E = /"(?:[^"\r\n]+)?"/y;
+
+function value(e) {
+  var t;
+  var a;
+  if (advance(s)) {
+    t = {
+      kind: r.NULL
+    };
+  } else if (a = advance(d)) {
+    t = {
+      kind: r.BOOLEAN,
+      value: "true" === a
+    };
+  } else if (!e && (a = advance(u))) {
+    t = {
+      kind: r.VARIABLE,
+      name: {
+        kind: r.NAME,
+        value: a.slice(1)
+      }
+    };
+  } else if (a = advance(l)) {
+    t = {
+      kind: r.FLOAT,
+      value: a
+    };
+  } else if (a = advance(v)) {
+    t = {
+      kind: r.INT,
+      value: a
+    };
+  } else if (a = advance(o)) {
+    t = {
+      kind: r.ENUM,
+      value: a
+    };
+  } else if (a = advance(f)) {
+    t = {
+      kind: r.STRING,
+      value: blockString(a.slice(3, -3)),
+      block: !0
+    };
+  } else if (a = advance(E)) {
+    t = {
+      kind: r.STRING,
+      value: c.test(a) ? JSON.parse(a) : a.slice(1, -1),
+      block: !1
+    };
+  } else if (t = function list(e) {
+    var t;
+    if (91 === i.charCodeAt(n)) {
+      n++;
+      ignored();
+      var a = [];
+      while (t = value(e)) {
+        a.push(t);
+      }
+      if (93 !== i.charCodeAt(n++)) {
+        throw error(r.LIST);
+      }
+      ignored();
+      return {
+        kind: r.LIST,
+        values: a
+      };
+    }
+  }(e) || function object(e) {
+    if (123 === i.charCodeAt(n)) {
+      n++;
+      ignored();
+      var t = [];
+      var a;
+      while (a = name()) {
+        ignored();
+        if (58 !== i.charCodeAt(n++)) {
+          throw error(r.OBJECT_FIELD);
+        }
+        ignored();
+        var o = value(e);
+        if (!o) {
+          throw error(r.OBJECT_FIELD);
+        }
+        t.push({
+          kind: r.OBJECT_FIELD,
+          name: a,
+          value: o
+        });
+      }
+      if (125 !== i.charCodeAt(n++)) {
+        throw error(r.OBJECT);
+      }
+      ignored();
+      return {
+        kind: r.OBJECT,
+        fields: t
+      };
+    }
+  }(e)) {
+    return t;
+  }
+  ignored();
+  return t;
+}
+
+function arguments_(e) {
+  var t = [];
+  ignored();
+  if (40 === i.charCodeAt(n)) {
+    n++;
+    ignored();
+    var a;
+    while (a = name()) {
+      ignored();
+      if (58 !== i.charCodeAt(n++)) {
+        throw error(r.ARGUMENT);
+      }
+      ignored();
+      var o = value(e);
+      if (!o) {
+        throw error(r.ARGUMENT);
+      }
+      t.push({
+        kind: r.ARGUMENT,
+        name: a,
+        value: o
+      });
+    }
+    if (!t.length || 41 !== i.charCodeAt(n++)) {
+      throw error(r.ARGUMENT);
+    }
+    ignored();
+  }
+  return t;
+}
+
+function directives(e) {
+  var t = [];
+  ignored();
+  while (64 === i.charCodeAt(n)) {
+    n++;
+    var a = name();
+    if (!a) {
+      throw error(r.DIRECTIVE);
+    }
+    ignored();
+    t.push({
+      kind: r.DIRECTIVE,
+      name: a,
+      arguments: arguments_(e)
+    });
+  }
+  return t;
+}
+
+function field() {
+  ignored();
+  var e = name();
+  if (e) {
+    ignored();
+    var t;
+    if (58 === i.charCodeAt(n)) {
+      n++;
+      ignored();
+      t = e;
+      if (!(e = name())) {
+        throw error(r.FIELD);
+      }
+      ignored();
+    }
+    return {
+      kind: r.FIELD,
+      alias: t,
+      name: e,
+      arguments: arguments_(!1),
+      directives: directives(!1),
+      selectionSet: selectionSet()
+    };
+  }
+}
+
+function type() {
+  var e;
+  ignored();
+  if (91 === i.charCodeAt(n)) {
+    n++;
+    ignored();
+    var t = type();
+    if (!t || 93 !== i.charCodeAt(n++)) {
+      throw error(r.LIST_TYPE);
+    }
+    e = {
+      kind: r.LIST_TYPE,
+      type: t
+    };
+  } else if (e = name()) {
+    e = {
+      kind: r.NAMED_TYPE,
+      name: e
+    };
+  } else {
+    throw error(r.NAMED_TYPE);
+  }
+  ignored();
+  if (33 === i.charCodeAt(n)) {
+    n++;
+    ignored();
+    return {
+      kind: r.NON_NULL_TYPE,
+      type: e
+    };
+  } else {
+    return e;
+  }
+}
+
+var p = /on/y;
+
+function typeCondition() {
+  if (advance(p)) {
+    ignored();
+    var e = name();
+    if (!e) {
+      throw error(r.NAMED_TYPE);
+    }
+    ignored();
+    return {
+      kind: r.NAMED_TYPE,
+      name: e
+    };
+  }
+}
+
+var I = /\.\.\./y;
+
+function fragmentSpread() {
+  ignored();
+  if (advance(I)) {
+    ignored();
+    var e;
+    if (e = name()) {
+      return {
+        kind: r.FRAGMENT_SPREAD,
+        name: e,
+        directives: directives(!1)
+      };
+    } else {
+      var i = typeCondition();
+      var n = directives(!1);
+      var t = selectionSet();
+      if (!t) {
+        throw error(r.INLINE_FRAGMENT);
+      }
+      return {
+        kind: r.INLINE_FRAGMENT,
+        typeCondition: i,
+        directives: n,
+        selectionSet: t
+      };
+    }
+  }
+}
+
+function selectionSet() {
+  var e;
+  ignored();
+  if (123 === i.charCodeAt(n)) {
+    n++;
+    ignored();
+    var t = [];
+    while (e = fragmentSpread() || field()) {
+      t.push(e);
+    }
+    if (!t.length || 125 !== i.charCodeAt(n++)) {
+      throw error(r.SELECTION_SET);
+    }
+    ignored();
+    return {
+      kind: r.SELECTION_SET,
+      selections: t
+    };
+  }
+}
+
+var N = /fragment/y;
+
+function fragmentDefinition() {
+  if (advance(N)) {
+    ignored();
+    var e = name();
+    if (!e) {
+      throw error(r.FRAGMENT_DEFINITION);
+    }
+    ignored();
+    var i = typeCondition();
+    if (!i) {
+      throw error(r.FRAGMENT_DEFINITION);
+    }
+    var n = directives(!1);
+    var t = selectionSet();
+    if (!t) {
+      throw error(r.FRAGMENT_DEFINITION);
+    }
+    return {
+      kind: r.FRAGMENT_DEFINITION,
+      name: e,
+      typeCondition: i,
+      directives: n,
+      selectionSet: t
+    };
+  }
+}
+
+var T = /query|mutation|subscription/y;
+
+function operationDefinition() {
+  var e;
+  var t;
+  var a = [];
+  var o = [];
+  if (e = advance(T)) {
+    ignored();
+    t = name();
+    a = function variableDefinitions() {
+      var e;
+      var t = [];
+      ignored();
+      if (40 === i.charCodeAt(n)) {
+        n++;
+        ignored();
+        while (e = advance(u)) {
+          ignored();
+          if (58 !== i.charCodeAt(n++)) {
+            throw error(r.VARIABLE_DEFINITION);
+          }
+          var a = type();
+          if (!a) {
+            throw error(r.VARIABLE_DEFINITION);
+          }
+          var o = void 0;
+          if (61 === i.charCodeAt(n)) {
+            n++;
+            ignored();
+            if (!(o = value(!0))) {
+              throw error(r.VARIABLE_DEFINITION);
+            }
+          }
+          ignored();
+          t.push({
+            kind: r.VARIABLE_DEFINITION,
+            variable: {
+              kind: r.VARIABLE,
+              name: {
+                kind: r.NAME,
+                value: e.slice(1)
+              }
+            },
+            type: a,
+            defaultValue: o,
+            directives: directives(!0)
+          });
+        }
+        if (41 !== i.charCodeAt(n++)) {
+          throw error(r.VARIABLE_DEFINITION);
+        }
+        ignored();
+      }
+      return t;
+    }();
+    o = directives(!1);
+  }
+  var s = selectionSet();
+  if (s) {
+    return {
+      kind: r.OPERATION_DEFINITION,
+      operation: e || "query",
+      name: t,
+      variableDefinitions: a,
+      directives: o,
+      selectionSet: s
+    };
+  }
+}
+
+function parse(e) {
+  i = e;
+  n = 0;
+  return function document() {
+    var e;
+    ignored();
+    var t = [];
+    while (e = fragmentDefinition() || operationDefinition()) {
+      t.push(e);
+    }
+    if (n !== i.length) {
+      throw error(r.DOCUMENT);
+    }
+    return {
+      kind: r.DOCUMENT,
+      definitions: t
+    };
+  }();
+}
+
+function parseValue(e) {
+  i = e;
+  n = 0;
+  ignored();
+  return value(!1);
+}
+
+function parseType(e) {
+  i = e;
+  n = 0;
+  return type();
+}
+
+var A = {};
+
+function visit(e, r) {
+  var i = [];
+  var n = [];
+  try {
+    var t = function traverse(e, t, a) {
+      var o = !1;
+      var s = r[e.kind] && r[e.kind].enter || r[e.kind];
+      var d = s && s.call(r, e, t, a, n, i);
+      if (!1 === d) {
+        return e;
+      } else if (null === d) {
+        return null;
+      } else if (d === A) {
+        throw A;
+      } else if (d && "string" == typeof d.kind) {
+        o = d !== e;
+        e = d;
+      }
+      if (a) {
+        i.push(a);
+      }
+      var u;
+      var v = {
+        ...e
+      };
+      for (var l in e) {
+        n.push(l);
+        var c = e[l];
+        if (Array.isArray(c)) {
+          var f = [];
+          for (var E = 0; E < c.length; E++) {
+            if (null != c[E] && "string" == typeof c[E].kind) {
+              i.push(e);
+              n.push(E);
+              u = traverse(c[E], E, c);
+              n.pop();
+              i.pop();
+              if (void 0 === u) {
+                f.push(c[E]);
+              } else if (null === u) {
+                o = !0;
+              } else {
+                o = o || u !== c[E];
+                f.push(u);
+              }
+            }
+          }
+          c = f;
+        } else if (null != c && "string" == typeof c.kind) {
+          if (void 0 !== (u = traverse(c, l, e))) {
+            o = o || c !== u;
+            c = u;
+          }
+        }
+        n.pop();
+        if (o) {
+          v[l] = c;
+        }
+      }
+      if (a) {
+        i.pop();
+      }
+      var p = r[e.kind] && r[e.kind].leave;
+      var I = p && p.call(r, e, t, a, n, i);
+      if (I === A) {
+        throw A;
+      } else if (void 0 !== I) {
+        return I;
+      } else if (void 0 !== d) {
+        return o ? v : d;
+      } else {
+        return o ? v : e;
+      }
+    }(e);
+    return void 0 !== t && !1 !== t ? t : e;
+  } catch (r) {
+    if (r !== A) {
+      throw r;
+    }
+    return e;
+  }
+}
+
+function printString(e) {
+  return JSON.stringify(e);
+}
+
+function printBlockString(e) {
+  return '"""\n' + e.replace(/"""/g, '\\"""') + '\n"""';
+}
+
+var hasItems = e => !(!e || !e.length);
+
+function print(e) {
+  var i;
+  switch (e.kind) {
+   case r.OPERATION_DEFINITION:
+    if ("query" === e.operation && !e.name && !hasItems(e.variableDefinitions) && !hasItems(e.directives)) {
+      return print(e.selectionSet);
+    }
+    i = e.operation;
+    if (e.name) {
+      i += " " + e.name.value;
+    }
+    if (hasItems(e.variableDefinitions)) {
+      if (!e.name) {
+        i += " ";
+      }
+      i += "(" + e.variableDefinitions.map(print).join(", ") + ")";
+    }
+    if (hasItems(e.directives)) {
+      i += " " + e.directives.map(print).join(" ");
+    }
+    return i + " " + print(e.selectionSet);
+
+   case r.VARIABLE_DEFINITION:
+    i = print(e.variable) + ": " + print(e.type);
+    if (e.defaultValue) {
+      i += " = " + print(e.defaultValue);
+    }
+    if (hasItems(e.directives)) {
+      i += " " + e.directives.map(print).join(" ");
+    }
+    return i;
+
+   case r.FIELD:
+    i = (e.alias ? print(e.alias) + ": " : "") + e.name.value;
+    if (hasItems(e.arguments)) {
+      i += "(" + e.arguments.map(print).join(", ") + ")";
+    }
+    if (hasItems(e.directives)) {
+      i += " " + e.directives.map(print).join(" ");
+    }
+    return e.selectionSet ? i + " " + print(e.selectionSet) : i;
+
+   case r.STRING:
+    return e.block ? printBlockString(e.value) : printString(e.value);
+
+   case r.BOOLEAN:
+    return "" + e.value;
+
+   case r.NULL:
+    return "null";
+
+   case r.INT:
+   case r.FLOAT:
+   case r.ENUM:
+   case r.NAME:
+    return e.value;
+
+   case r.LIST:
+    return "[" + e.values.map(print).join(", ") + "]";
+
+   case r.OBJECT:
+    return "{" + e.fields.map(print).join(", ") + "}";
+
+   case r.OBJECT_FIELD:
+    return e.name.value + ": " + print(e.value);
+
+   case r.VARIABLE:
+    return "$" + e.name.value;
+
+   case r.DOCUMENT:
+    return hasItems(e.definitions) ? e.definitions.map(print).join("\n\n") : "";
+
+   case r.SELECTION_SET:
+    return "{\n  " + e.selections.map(print).join("\n").replace(/\n/g, "\n  ") + "\n}";
+
+   case r.ARGUMENT:
+    return e.name.value + ": " + print(e.value);
+
+   case r.FRAGMENT_SPREAD:
+    i = "..." + e.name.value;
+    if (hasItems(e.directives)) {
+      i += " " + e.directives.map(print).join(" ");
+    }
+    return i;
+
+   case r.INLINE_FRAGMENT:
+    i = "...";
+    if (e.typeCondition) {
+      i += " on " + e.typeCondition.name.value;
+    }
+    if (hasItems(e.directives)) {
+      i += " " + e.directives.map(print).join(" ");
+    }
+    return i + " " + print(e.selectionSet);
+
+   case r.FRAGMENT_DEFINITION:
+    i = "fragment " + e.name.value;
+    i += " on " + e.typeCondition.name.value;
+    if (hasItems(e.directives)) {
+      i += " " + e.directives.map(print).join(" ");
+    }
+    return i + " " + print(e.selectionSet);
+
+   case r.DIRECTIVE:
+    i = "@" + e.name.value;
+    if (hasItems(e.arguments)) {
+      i += "(" + e.arguments.map(print).join(", ") + ")";
+    }
+    return i;
+
+   case r.NAMED_TYPE:
+    return e.name.value;
+
+   case r.LIST_TYPE:
+    return "[" + print(e.type) + "]";
+
+   case r.NON_NULL_TYPE:
+    return print(e.type) + "!";
+  }
+}
+
+export { A as BREAK, GraphQLError, r as Kind, e as OperationTypeNode, blockString, parse, parseType, parseValue, print, printBlockString, printString, visit };
+//# sourceMappingURL=graphql.web.mjs.map