@noxickon/onyx 0.0.1 → 0.0.2

package/dist/chunks/index-1-zQ3RaM.js

@@ -0,0 +1,601 @@
+import { g as te } from "./_commonjsHelpers-C6fGbg64.js";
+import re from "react";
+function ne(t, e) {
+  for (var r = 0; r < e.length; r++) {
+    const n = e[r];
+    if (typeof n != "string" && !Array.isArray(n)) {
+      for (const o in n)
+        if (o !== "default" && !(o in t)) {
+          const i = Object.getOwnPropertyDescriptor(n, o);
+          i && Object.defineProperty(t, o, i.get ? i : {
+            enumerable: !0,
+            get: () => n[o]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var N = function(t, e) {
+  return N = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(r, n) {
+    r.__proto__ = n;
+  } || function(r, n) {
+    for (var o in n) Object.prototype.hasOwnProperty.call(n, o) && (r[o] = n[o]);
+  }, N(t, e);
+};
+function B(t, e) {
+  if (typeof e != "function" && e !== null)
+    throw new TypeError("Class extends value " + String(e) + " is not a constructor or null");
+  N(t, e);
+  function r() {
+    this.constructor = t;
+  }
+  t.prototype = e === null ? Object.create(e) : (r.prototype = e.prototype, new r());
+}
+var w = function() {
+  return w = Object.assign || function(e) {
+    for (var r, n = 1, o = arguments.length; n < o; n++) {
+      r = arguments[n];
+      for (var i in r) Object.prototype.hasOwnProperty.call(r, i) && (e[i] = r[i]);
+    }
+    return e;
+  }, w.apply(this, arguments);
+};
+function Te(t, e) {
+  var r = {};
+  for (var n in t) Object.prototype.hasOwnProperty.call(t, n) && e.indexOf(n) < 0 && (r[n] = t[n]);
+  if (t != null && typeof Object.getOwnPropertySymbols == "function")
+    for (var o = 0, n = Object.getOwnPropertySymbols(t); o < n.length; o++)
+      e.indexOf(n[o]) < 0 && Object.prototype.propertyIsEnumerable.call(t, n[o]) && (r[n[o]] = t[n[o]]);
+  return r;
+}
+function v(t, e, r) {
+  if (r || arguments.length === 2) for (var n = 0, o = e.length, i; n < o; n++)
+    (i || !(n in e)) && (i || (i = Array.prototype.slice.call(e, 0, n)), i[n] = e[n]);
+  return t.concat(i || Array.prototype.slice.call(e));
+}
+var S = "Invariant Violation", T = Object.setPrototypeOf, oe = T === void 0 ? function(t, e) {
+  return t.__proto__ = e, t;
+} : T, J = (
+  /** @class */
+  function(t) {
+    B(e, t);
+    function e(r) {
+      r === void 0 && (r = S);
+      var n = t.call(this, typeof r == "number" ? S + ": " + r + " (see https://github.com/apollographql/invariant-packages)" : r) || this;
+      return n.framesToPop = 1, n.name = S, oe(n, e.prototype), n;
+    }
+    return e;
+  }(Error)
+);
+function p(t, e) {
+  if (!t)
+    throw new J(e);
+}
+var $ = ["debug", "log", "warn", "error", "silent"], ie = $.indexOf("log");
+function E(t) {
+  return function() {
+    if ($.indexOf(t) >= ie) {
+      var e = console[t] || console.log;
+      return e.apply(console, arguments);
+    }
+  };
+}
+(function(t) {
+  t.debug = E("debug"), t.log = E("log"), t.warn = E("warn"), t.error = E("error");
+})(p || (p = {}));
+var Y = "3.13.8";
+function c(t) {
+  try {
+    return t();
+  } catch {
+  }
+}
+const A = c(function() {
+  return globalThis;
+}) || c(function() {
+  return window;
+}) || c(function() {
+  return self;
+}) || c(function() {
+  return global;
+}) || // We don't expect the Function constructor ever to be invoked at runtime, as
+// long as at least one of globalThis, window, self, or global is defined, so
+// we are under no obligation to make it easy for static analysis tools to
+// detect syntactic usage of the Function constructor. If you think you can
+// improve your static analysis to detect this obfuscation, think again. This
+// is an arms race you cannot win, at least not in JavaScript.
+c(function() {
+  return c.constructor("return this")();
+});
+var L = /* @__PURE__ */ new Map();
+function se(t) {
+  var e = L.get(t) || 1;
+  return L.set(t, e + 1), "".concat(t, ":").concat(e, ":").concat(Math.random().toString(36).slice(2));
+}
+function ae(t, e) {
+  var r = se("stringifyForDisplay");
+  return JSON.stringify(t, function(n, o) {
+    return o === void 0 ? r : o;
+  }, e).split(JSON.stringify(r)).join("<undefined>");
+}
+function O(t) {
+  return function(e) {
+    for (var r = [], n = 1; n < arguments.length; n++)
+      r[n - 1] = arguments[n];
+    if (typeof e == "number") {
+      var o = e;
+      e = C(o), e || (e = M(o, r), r = []);
+    }
+    t.apply(void 0, [e].concat(r));
+  };
+}
+var d = Object.assign(function(e, r) {
+  for (var n = [], o = 2; o < arguments.length; o++)
+    n[o - 2] = arguments[o];
+  e || p(e, C(r, n) || M(r, n));
+}, {
+  debug: O(p.debug),
+  log: O(p.log),
+  warn: O(p.warn),
+  error: O(p.error)
+});
+function Le(t) {
+  for (var e = [], r = 1; r < arguments.length; r++)
+    e[r - 1] = arguments[r];
+  return new J(C(t, e) || M(t, e));
+}
+var P = Symbol.for("ApolloErrorMessageHandler_" + Y);
+function X(t) {
+  if (typeof t == "string")
+    return t;
+  try {
+    return ae(t, 2).slice(0, 1e3);
+  } catch {
+    return "<non-serializable>";
+  }
+}
+function C(t, e) {
+  if (e === void 0 && (e = []), !!t)
+    return A[P] && A[P](t, e.map(X));
+}
+function M(t, e) {
+  if (e === void 0 && (e = []), !!t)
+    return "An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#".concat(encodeURIComponent(JSON.stringify({
+      version: Y,
+      message: t,
+      args: e.map(X)
+    })));
+}
+var le = c(function() {
+  return navigator.product;
+}) == "ReactNative", ue = typeof Symbol == "function" && typeof Symbol.for == "function", ce = typeof c(function() {
+  return window.document.createElement;
+}) == "function", fe = (
+  // Following advice found in this comment from @domenic (maintainer of jsdom):
+  // https://github.com/jsdom/jsdom/issues/1537#issuecomment-229405327
+  //
+  // Since we control the version of Jest and jsdom used when running Apollo
+  // Client tests, and that version is recent enought to include " jsdom/x.y.z"
+  // at the end of the user agent string, I believe this case is all we need to
+  // check. Testing for "Node.js" was recommended for backwards compatibility
+  // with older version of jsdom, but we don't have that problem.
+  c(function() {
+    return navigator.userAgent.indexOf("jsdom") >= 0;
+  }) || !1
+), Pe = (ce || le) && !fe;
+function he(t) {
+  return t !== null && typeof t == "object";
+}
+function pe() {
+}
+class D {
+  constructor(e = 1 / 0, r = pe) {
+    this.max = e, this.dispose = r, this.map = /* @__PURE__ */ new Map(), this.newest = null, this.oldest = null;
+  }
+  has(e) {
+    return this.map.has(e);
+  }
+  get(e) {
+    const r = this.getNode(e);
+    return r && r.value;
+  }
+  get size() {
+    return this.map.size;
+  }
+  getNode(e) {
+    const r = this.map.get(e);
+    if (r && r !== this.newest) {
+      const { older: n, newer: o } = r;
+      o && (o.older = n), n && (n.newer = o), r.older = this.newest, r.older.newer = r, r.newer = null, this.newest = r, r === this.oldest && (this.oldest = o);
+    }
+    return r;
+  }
+  set(e, r) {
+    let n = this.getNode(e);
+    return n ? n.value = r : (n = {
+      key: e,
+      value: r,
+      newer: null,
+      older: this.newest
+    }, this.newest && (this.newest.newer = n), this.newest = n, this.oldest = this.oldest || n, this.map.set(e, n), n.value);
+  }
+  clean() {
+    for (; this.oldest && this.map.size > this.max; )
+      this.delete(this.oldest.key);
+  }
+  delete(e) {
+    const r = this.map.get(e);
+    return r ? (r === this.newest && (this.newest = r.older), r === this.oldest && (this.oldest = r.newer), r.newer && (r.newer.older = r.older), r.older && (r.older.newer = r.newer), this.map.delete(e), this.dispose(r.value, e), !0) : !1;
+  }
+}
+function z() {
+}
+const de = z, ge = typeof WeakRef < "u" ? WeakRef : function(t) {
+  return { deref: () => t };
+}, ve = typeof WeakMap < "u" ? WeakMap : Map, ye = typeof FinalizationRegistry < "u" ? FinalizationRegistry : function() {
+  return {
+    register: z,
+    unregister: z
+  };
+}, we = 10024;
+class U {
+  constructor(e = 1 / 0, r = de) {
+    this.max = e, this.dispose = r, this.map = new ve(), this.newest = null, this.oldest = null, this.unfinalizedNodes = /* @__PURE__ */ new Set(), this.finalizationScheduled = !1, this.size = 0, this.finalize = () => {
+      const n = this.unfinalizedNodes.values();
+      for (let o = 0; o < we; o++) {
+        const i = n.next().value;
+        if (!i)
+          break;
+        this.unfinalizedNodes.delete(i);
+        const s = i.key;
+        delete i.key, i.keyRef = new ge(s), this.registry.register(s, i, i);
+      }
+      this.unfinalizedNodes.size > 0 ? queueMicrotask(this.finalize) : this.finalizationScheduled = !1;
+    }, this.registry = new ye(this.deleteNode.bind(this));
+  }
+  has(e) {
+    return this.map.has(e);
+  }
+  get(e) {
+    const r = this.getNode(e);
+    return r && r.value;
+  }
+  getNode(e) {
+    const r = this.map.get(e);
+    if (r && r !== this.newest) {
+      const { older: n, newer: o } = r;
+      o && (o.older = n), n && (n.newer = o), r.older = this.newest, r.older.newer = r, r.newer = null, this.newest = r, r === this.oldest && (this.oldest = o);
+    }
+    return r;
+  }
+  set(e, r) {
+    let n = this.getNode(e);
+    return n ? n.value = r : (n = {
+      key: e,
+      value: r,
+      newer: null,
+      older: this.newest
+    }, this.newest && (this.newest.newer = n), this.newest = n, this.oldest = this.oldest || n, this.scheduleFinalization(n), this.map.set(e, n), this.size++, n.value);
+  }
+  clean() {
+    for (; this.oldest && this.size > this.max; )
+      this.deleteNode(this.oldest);
+  }
+  deleteNode(e) {
+    e === this.newest && (this.newest = e.older), e === this.oldest && (this.oldest = e.newer), e.newer && (e.newer.older = e.older), e.older && (e.older.newer = e.newer), this.size--;
+    const r = e.key || e.keyRef && e.keyRef.deref();
+    this.dispose(e.value, r), e.keyRef ? this.registry.unregister(e) : this.unfinalizedNodes.delete(e), r && this.map.delete(r);
+  }
+  delete(e) {
+    const r = this.map.get(e);
+    return r ? (this.deleteNode(r), !0) : !1;
+  }
+  scheduleFinalization(e) {
+    this.unfinalizedNodes.add(e), this.finalizationScheduled || (this.finalizationScheduled = !0, queueMicrotask(this.finalize));
+  }
+}
+var j = /* @__PURE__ */ new WeakSet();
+function Z(t) {
+  t.size <= (t.max || -1) || j.has(t) || (j.add(t), setTimeout(function() {
+    t.clean(), j.delete(t);
+  }, 100));
+}
+var be = function(t, e) {
+  var r = new U(t, e);
+  return r.set = function(n, o) {
+    var i = U.prototype.set.call(this, n, o);
+    return Z(this), i;
+  }, r;
+}, De = function(t, e) {
+  var r = new D(t, e);
+  return r.set = function(n, o) {
+    var i = D.prototype.set.call(this, n, o);
+    return Z(this), i;
+  }, r;
+}, _e = Symbol.for("apollo.cacheSize"), Ee = w({}, A[_e]), Oe = {};
+function me(t, e) {
+  Oe[t] = e;
+}
+function F() {
+  for (var t = [], e = 0; e < arguments.length; e++)
+    t[e] = arguments[e];
+  var r = /* @__PURE__ */ Object.create(null);
+  return t.forEach(function(n) {
+    n && Object.keys(n).forEach(function(o) {
+      var i = n[o];
+      i !== void 0 && (r[o] = i);
+    });
+  }), r;
+}
+function Ue(t, e) {
+  return F(t, e, e.variables && {
+    variables: F(w(w({}, t && t.variables), e.variables))
+  });
+}
+function Fe(t) {
+  return t.hasOwnProperty("graphQLErrors");
+}
+var Se = function(t) {
+  var e = v(v(v([], t.graphQLErrors, !0), t.clientErrors, !0), t.protocolErrors, !0);
+  return t.networkError && e.push(t.networkError), e.map(function(r) {
+    return he(r) && r.message || "Error message not found.";
+  }).join(`
+`);
+}, We = (
+  /** @class */
+  function(t) {
+    B(e, t);
+    function e(r) {
+      var n = r.graphQLErrors, o = r.protocolErrors, i = r.clientErrors, s = r.networkError, a = r.errorMessage, u = r.extraInfo, l = t.call(this, a) || this;
+      return l.name = "ApolloError", l.graphQLErrors = n || [], l.protocolErrors = o || [], l.clientErrors = i || [], l.networkError = s || null, l.message = a || Se(l), l.extraInfo = u, l.cause = v(v(v([
+        s
+      ], n || [], !0), o || [], !0), i || [], !0).find(function(b) {
+        return !!b;
+      }) || null, l.__proto__ = e.prototype, l;
+    }
+    return e;
+  }(Error)
+);
+const { toString: W, hasOwnProperty: je } = Object.prototype, q = Function.prototype.toString, x = /* @__PURE__ */ new Map();
+function qe(t, e) {
+  try {
+    return R(t, e);
+  } finally {
+    x.clear();
+  }
+}
+function R(t, e) {
+  if (t === e)
+    return !0;
+  const r = W.call(t), n = W.call(e);
+  if (r !== n)
+    return !1;
+  switch (r) {
+    case "[object Array]":
+      if (t.length !== e.length)
+        return !1;
+    // Fall through to object case...
+    case "[object Object]": {
+      if (K(t, e))
+        return !0;
+      const o = Q(t), i = Q(e), s = o.length;
+      if (s !== i.length)
+        return !1;
+      for (let a = 0; a < s; ++a)
+        if (!je.call(e, o[a]))
+          return !1;
+      for (let a = 0; a < s; ++a) {
+        const u = o[a];
+        if (!R(t[u], e[u]))
+          return !1;
+      }
+      return !0;
+    }
+    case "[object Error]":
+      return t.name === e.name && t.message === e.message;
+    case "[object Number]":
+      if (t !== t)
+        return e !== e;
+    // Fall through to shared +a === +b case...
+    case "[object Boolean]":
+    case "[object Date]":
+      return +t == +e;
+    case "[object RegExp]":
+    case "[object String]":
+      return t == `${e}`;
+    case "[object Map]":
+    case "[object Set]": {
+      if (t.size !== e.size)
+        return !1;
+      if (K(t, e))
+        return !0;
+      const o = t.entries(), i = r === "[object Map]";
+      for (; ; ) {
+        const s = o.next();
+        if (s.done)
+          break;
+        const [a, u] = s.value;
+        if (!e.has(a) || i && !R(u, e.get(a)))
+          return !1;
+      }
+      return !0;
+    }
+    case "[object Uint16Array]":
+    case "[object Uint8Array]":
+    // Buffer, in Node.js.
+    case "[object Uint32Array]":
+    case "[object Int32Array]":
+    case "[object Int8Array]":
+    case "[object Int16Array]":
+    case "[object ArrayBuffer]":
+      t = new Uint8Array(t), e = new Uint8Array(e);
+    // Fall through...
+    case "[object DataView]": {
+      let o = t.byteLength;
+      if (o === e.byteLength)
+        for (; o-- && t[o] === e[o]; )
+          ;
+      return o === -1;
+    }
+    case "[object AsyncFunction]":
+    case "[object GeneratorFunction]":
+    case "[object AsyncGeneratorFunction]":
+    case "[object Function]": {
+      const o = q.call(t);
+      return o !== q.call(e) ? !1 : !Ae(o, Ne);
+    }
+  }
+  return !1;
+}
+function Q(t) {
+  return Object.keys(t).filter(ke, t);
+}
+function ke(t) {
+  return this[t] !== void 0;
+}
+const Ne = "{ [native code] }";
+function Ae(t, e) {
+  const r = t.length - e.length;
+  return r >= 0 && t.indexOf(e, r) === r;
+}
+function K(t, e) {
+  let r = x.get(t);
+  if (r) {
+    if (r.has(e))
+      return !0;
+  } else
+    x.set(t, r = /* @__PURE__ */ new Set());
+  return r.add(e), !1;
+}
+var k = { exports: {} }, G;
+function ze() {
+  return G || (G = 1, function(t) {
+    t.exports.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = void 0, t.exports.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = void 0, t.exports.__SERVER_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE = void 0, Object.assign(t.exports, re);
+  }(k)), k.exports;
+}
+var y = ze();
+const xe = /* @__PURE__ */ te(y), Re = /* @__PURE__ */ ne({
+  __proto__: null,
+  default: xe
+}, [y]);
+var H = ue ? Symbol.for("__APOLLO_CONTEXT__") : "__APOLLO_CONTEXT__";
+function Ce() {
+  d("createContext" in Re, 54);
+  var t = y.createContext[H];
+  return t || (Object.defineProperty(y.createContext, H, {
+    value: t = y.createContext({}),
+    enumerable: !1,
+    writable: !1,
+    configurable: !0
+  }), t.displayName = "ApolloContext"), t;
+}
+function Qe(t) {
+  var e = y.useContext(Ce()), r = t || e.client;
+  return d(!!r, 58), r;
+}
+var f;
+(function(t) {
+  t[t.Query = 0] = "Query", t[t.Mutation = 1] = "Mutation", t[t.Subscription = 2] = "Subscription";
+})(f || (f = {}));
+var g;
+function V(t) {
+  var e;
+  switch (t) {
+    case f.Query:
+      e = "Query";
+      break;
+    case f.Mutation:
+      e = "Mutation";
+      break;
+    case f.Subscription:
+      e = "Subscription";
+      break;
+  }
+  return e;
+}
+function ee(t) {
+  g || (g = new be(
+    Ee.parser || 1e3
+    /* defaultCacheSizes.parser */
+  ));
+  var e = g.get(t);
+  if (e)
+    return e;
+  var r, n, o;
+  d(!!t && !!t.kind, 70, t);
+  for (var i = [], s = [], a = [], u = [], l = 0, b = t.definitions; l < b.length; l++) {
+    var h = b[l];
+    if (h.kind === "FragmentDefinition") {
+      i.push(h);
+      continue;
+    }
+    if (h.kind === "OperationDefinition")
+      switch (h.operation) {
+        case "query":
+          s.push(h);
+          break;
+        case "mutation":
+          a.push(h);
+          break;
+        case "subscription":
+          u.push(h);
+          break;
+      }
+  }
+  d(!i.length || s.length || a.length || u.length, 71), d(
+    s.length + a.length + u.length <= 1,
+    72,
+    t,
+    s.length,
+    u.length,
+    a.length
+  ), n = s.length ? f.Query : f.Mutation, !s.length && !a.length && (n = f.Subscription);
+  var m = s.length ? s : a.length ? a : u;
+  d(m.length === 1, 73, t, m.length);
+  var _ = m[0];
+  r = _.variableDefinitions || [], _.name && _.name.kind === "Name" ? o = _.name.value : o = "data";
+  var I = { name: o, type: n, variables: r };
+  return g.set(t, I), I;
+}
+ee.resetCache = function() {
+  g = void 0;
+};
+globalThis.__DEV__ !== !1 && me("parser", function() {
+  return g ? g.size : 0;
+});
+function Ke(t, e) {
+  var r = ee(t), n = V(e), o = V(r.type);
+  d(
+    r.type === e,
+    74,
+    n,
+    n,
+    o
+  );
+}
+export {
+  De as A,
+  f as D,
+  Re as R,
+  w as _,
+  he as a,
+  ue as b,
+  Ee as c,
+  Te as d,
+  qe as e,
+  B as f,
+  F as g,
+  Fe as h,
+  d as i,
+  We as j,
+  y as k,
+  Pe as l,
+  Ce as m,
+  Le as n,
+  Ue as o,
+  ce as p,
+  me as r,
+  Qe as u,
+  Ke as v
+};