react-shared-states 1.0.0

package/dist/main.js

@@ -0,0 +1,820 @@
+/*!
+* react-shared-states v1.0.0
+* (c) Hichem Taboukouyout
+* Released under the MIT License.
+* Github: github.com/HichemTab-tech/react-shared-states
+*/
+
+import we, { createContext as hr, useMemo as br, useContext as Er, useSyncExternalStore as je } from "react";
+var q = { exports: {} }, W = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Oe;
+function _r() {
+  if (Oe) return W;
+  Oe = 1;
+  var l = we, t = Symbol.for("react.element"), i = Symbol.for("react.fragment"), a = Object.prototype.hasOwnProperty, b = l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, P = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function v(T, d, m) {
+    var S, C = {}, j = null, M = null;
+    m !== void 0 && (j = "" + m), d.key !== void 0 && (j = "" + d.key), d.ref !== void 0 && (M = d.ref);
+    for (S in d) a.call(d, S) && !P.hasOwnProperty(S) && (C[S] = d[S]);
+    if (T && T.defaultProps) for (S in d = T.defaultProps, d) C[S] === void 0 && (C[S] = d[S]);
+    return { $$typeof: t, type: T, key: j, ref: M, props: C, _owner: b.current };
+  }
+  return W.Fragment = i, W.jsx = v, W.jsxs = v, W;
+}
+var Y = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ce;
+function Rr() {
+  return Ce || (Ce = 1, process.env.NODE_ENV !== "production" && function() {
+    var l = we, t = Symbol.for("react.element"), i = Symbol.for("react.portal"), a = Symbol.for("react.fragment"), b = Symbol.for("react.strict_mode"), P = Symbol.for("react.profiler"), v = Symbol.for("react.provider"), T = Symbol.for("react.context"), d = Symbol.for("react.forward_ref"), m = Symbol.for("react.suspense"), S = Symbol.for("react.suspense_list"), C = Symbol.for("react.memo"), j = Symbol.for("react.lazy"), M = Symbol.for("react.offscreen"), ee = Symbol.iterator, Le = "@@iterator";
+    function Ve(e) {
+      if (e === null || typeof e != "object")
+        return null;
+      var r = ee && e[ee] || e[Le];
+      return typeof r == "function" ? r : null;
+    }
+    var L = l.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function E(e) {
+      {
+        for (var r = arguments.length, n = new Array(r > 1 ? r - 1 : 0), o = 1; o < r; o++)
+          n[o - 1] = arguments[o];
+        Ie("error", e, n);
+      }
+    }
+    function Ie(e, r, n) {
+      {
+        var o = L.ReactDebugCurrentFrame, f = o.getStackAddendum();
+        f !== "" && (r += "%s", n = n.concat([f]));
+        var c = n.map(function(u) {
+          return String(u);
+        });
+        c.unshift("Warning: " + r), Function.prototype.apply.call(console[e], console, c);
+      }
+    }
+    var $e = !1, De = !1, We = !1, Ye = !1, Me = !1, re;
+    re = Symbol.for("react.module.reference");
+    function ke(e) {
+      return !!(typeof e == "string" || typeof e == "function" || e === a || e === P || Me || e === b || e === m || e === S || Ye || e === M || $e || De || We || typeof e == "object" && e !== null && (e.$$typeof === j || e.$$typeof === C || e.$$typeof === v || e.$$typeof === T || e.$$typeof === d || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      e.$$typeof === re || e.getModuleId !== void 0));
+    }
+    function Ue(e, r, n) {
+      var o = e.displayName;
+      if (o)
+        return o;
+      var f = r.displayName || r.name || "";
+      return f !== "" ? n + "(" + f + ")" : n;
+    }
+    function te(e) {
+      return e.displayName || "Context";
+    }
+    function w(e) {
+      if (e == null)
+        return null;
+      if (typeof e.tag == "number" && E("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof e == "function")
+        return e.displayName || e.name || null;
+      if (typeof e == "string")
+        return e;
+      switch (e) {
+        case a:
+          return "Fragment";
+        case i:
+          return "Portal";
+        case P:
+          return "Profiler";
+        case b:
+          return "StrictMode";
+        case m:
+          return "Suspense";
+        case S:
+          return "SuspenseList";
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case T:
+            var r = e;
+            return te(r) + ".Consumer";
+          case v:
+            var n = e;
+            return te(n._context) + ".Provider";
+          case d:
+            return Ue(e, e.render, "ForwardRef");
+          case C:
+            var o = e.displayName || null;
+            return o !== null ? o : w(e.type) || "Memo";
+          case j: {
+            var f = e, c = f._payload, u = f._init;
+            try {
+              return w(u(c));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var A = Object.assign, $ = 0, ne, ae, ie, oe, se, ue, le;
+    function fe() {
+    }
+    fe.__reactDisabledLog = !0;
+    function Be() {
+      {
+        if ($ === 0) {
+          ne = console.log, ae = console.info, ie = console.warn, oe = console.error, se = console.group, ue = console.groupCollapsed, le = console.groupEnd;
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            value: fe,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: e,
+            log: e,
+            warn: e,
+            error: e,
+            group: e,
+            groupCollapsed: e,
+            groupEnd: e
+          });
+        }
+        $++;
+      }
+    }
+    function Je() {
+      {
+        if ($--, $ === 0) {
+          var e = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: A({}, e, {
+              value: ne
+            }),
+            info: A({}, e, {
+              value: ae
+            }),
+            warn: A({}, e, {
+              value: ie
+            }),
+            error: A({}, e, {
+              value: oe
+            }),
+            group: A({}, e, {
+              value: se
+            }),
+            groupCollapsed: A({}, e, {
+              value: ue
+            }),
+            groupEnd: A({}, e, {
+              value: le
+            })
+          });
+        }
+        $ < 0 && E("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var N = L.ReactCurrentDispatcher, K;
+    function k(e, r, n) {
+      {
+        if (K === void 0)
+          try {
+            throw Error();
+          } catch (f) {
+            var o = f.stack.trim().match(/\n( *(at )?)/);
+            K = o && o[1] || "";
+          }
+        return `
+` + K + e;
+      }
+    }
+    var G = !1, U;
+    {
+      var qe = typeof WeakMap == "function" ? WeakMap : Map;
+      U = new qe();
+    }
+    function ce(e, r) {
+      if (!e || G)
+        return "";
+      {
+        var n = U.get(e);
+        if (n !== void 0)
+          return n;
+      }
+      var o;
+      G = !0;
+      var f = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var c;
+      c = N.current, N.current = null, Be();
+      try {
+        if (r) {
+          var u = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(u.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(u, []);
+            } catch (x) {
+              o = x;
+            }
+            Reflect.construct(e, [], u);
+          } else {
+            try {
+              u.call();
+            } catch (x) {
+              o = x;
+            }
+            e.call(u.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (x) {
+            o = x;
+          }
+          e();
+        }
+      } catch (x) {
+        if (x && o && typeof x.stack == "string") {
+          for (var s = x.stack.split(`
+`), _ = o.stack.split(`
+`), p = s.length - 1, h = _.length - 1; p >= 1 && h >= 0 && s[p] !== _[h]; )
+            h--;
+          for (; p >= 1 && h >= 0; p--, h--)
+            if (s[p] !== _[h]) {
+              if (p !== 1 || h !== 1)
+                do
+                  if (p--, h--, h < 0 || s[p] !== _[h]) {
+                    var O = `
+` + s[p].replace(" at new ", " at ");
+                    return e.displayName && O.includes("<anonymous>") && (O = O.replace("<anonymous>", e.displayName)), typeof e == "function" && U.set(e, O), O;
+                  }
+                while (p >= 1 && h >= 0);
+              break;
+            }
+        }
+      } finally {
+        G = !1, N.current = c, Je(), Error.prepareStackTrace = f;
+      }
+      var I = e ? e.displayName || e.name : "", F = I ? k(I) : "";
+      return typeof e == "function" && U.set(e, F), F;
+    }
+    function Ne(e, r, n) {
+      return ce(e, !1);
+    }
+    function Ke(e) {
+      var r = e.prototype;
+      return !!(r && r.isReactComponent);
+    }
+    function B(e, r, n) {
+      if (e == null)
+        return "";
+      if (typeof e == "function")
+        return ce(e, Ke(e));
+      if (typeof e == "string")
+        return k(e);
+      switch (e) {
+        case m:
+          return k("Suspense");
+        case S:
+          return k("SuspenseList");
+      }
+      if (typeof e == "object")
+        switch (e.$$typeof) {
+          case d:
+            return Ne(e.render);
+          case C:
+            return B(e.type, r, n);
+          case j: {
+            var o = e, f = o._payload, c = o._init;
+            try {
+              return B(c(f), r, n);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var D = Object.prototype.hasOwnProperty, de = {}, ve = L.ReactDebugCurrentFrame;
+    function J(e) {
+      if (e) {
+        var r = e._owner, n = B(e.type, e._source, r ? r.type : null);
+        ve.setExtraStackFrame(n);
+      } else
+        ve.setExtraStackFrame(null);
+    }
+    function Ge(e, r, n, o, f) {
+      {
+        var c = Function.call.bind(D);
+        for (var u in e)
+          if (c(e, u)) {
+            var s = void 0;
+            try {
+              if (typeof e[u] != "function") {
+                var _ = Error((o || "React class") + ": " + n + " type `" + u + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof e[u] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw _.name = "Invariant Violation", _;
+              }
+              s = e[u](r, u, o, n, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (p) {
+              s = p;
+            }
+            s && !(s instanceof Error) && (J(f), E("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", o || "React class", n, u, typeof s), J(null)), s instanceof Error && !(s.message in de) && (de[s.message] = !0, J(f), E("Failed %s type: %s", n, s.message), J(null));
+          }
+      }
+    }
+    var ze = Array.isArray;
+    function z(e) {
+      return ze(e);
+    }
+    function Xe(e) {
+      {
+        var r = typeof Symbol == "function" && Symbol.toStringTag, n = r && e[Symbol.toStringTag] || e.constructor.name || "Object";
+        return n;
+      }
+    }
+    function He(e) {
+      try {
+        return pe(e), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function pe(e) {
+      return "" + e;
+    }
+    function ge(e) {
+      if (He(e))
+        return E("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", Xe(e)), pe(e);
+    }
+    var he = L.ReactCurrentOwner, Ze = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, be, Ee;
+    function Qe(e) {
+      if (D.call(e, "ref")) {
+        var r = Object.getOwnPropertyDescriptor(e, "ref").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.ref !== void 0;
+    }
+    function er(e) {
+      if (D.call(e, "key")) {
+        var r = Object.getOwnPropertyDescriptor(e, "key").get;
+        if (r && r.isReactWarning)
+          return !1;
+      }
+      return e.key !== void 0;
+    }
+    function rr(e, r) {
+      typeof e.ref == "string" && he.current;
+    }
+    function tr(e, r) {
+      {
+        var n = function() {
+          be || (be = !0, E("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        n.isReactWarning = !0, Object.defineProperty(e, "key", {
+          get: n,
+          configurable: !0
+        });
+      }
+    }
+    function nr(e, r) {
+      {
+        var n = function() {
+          Ee || (Ee = !0, E("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", r));
+        };
+        n.isReactWarning = !0, Object.defineProperty(e, "ref", {
+          get: n,
+          configurable: !0
+        });
+      }
+    }
+    var ar = function(e, r, n, o, f, c, u) {
+      var s = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: t,
+        // Built-in properties that belong on the element
+        type: e,
+        key: r,
+        ref: n,
+        props: u,
+        // Record the component responsible for creating this element.
+        _owner: c
+      };
+      return s._store = {}, Object.defineProperty(s._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(s, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: o
+      }), Object.defineProperty(s, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: f
+      }), Object.freeze && (Object.freeze(s.props), Object.freeze(s)), s;
+    };
+    function ir(e, r, n, o, f) {
+      {
+        var c, u = {}, s = null, _ = null;
+        n !== void 0 && (ge(n), s = "" + n), er(r) && (ge(r.key), s = "" + r.key), Qe(r) && (_ = r.ref, rr(r, f));
+        for (c in r)
+          D.call(r, c) && !Ze.hasOwnProperty(c) && (u[c] = r[c]);
+        if (e && e.defaultProps) {
+          var p = e.defaultProps;
+          for (c in p)
+            u[c] === void 0 && (u[c] = p[c]);
+        }
+        if (s || _) {
+          var h = typeof e == "function" ? e.displayName || e.name || "Unknown" : e;
+          s && tr(u, h), _ && nr(u, h);
+        }
+        return ar(e, s, _, f, o, he.current, u);
+      }
+    }
+    var X = L.ReactCurrentOwner, _e = L.ReactDebugCurrentFrame;
+    function V(e) {
+      if (e) {
+        var r = e._owner, n = B(e.type, e._source, r ? r.type : null);
+        _e.setExtraStackFrame(n);
+      } else
+        _e.setExtraStackFrame(null);
+    }
+    var H;
+    H = !1;
+    function Z(e) {
+      return typeof e == "object" && e !== null && e.$$typeof === t;
+    }
+    function Re() {
+      {
+        if (X.current) {
+          var e = w(X.current.type);
+          if (e)
+            return `
+
+Check the render method of \`` + e + "`.";
+        }
+        return "";
+      }
+    }
+    function or(e) {
+      return "";
+    }
+    var me = {};
+    function sr(e) {
+      {
+        var r = Re();
+        if (!r) {
+          var n = typeof e == "string" ? e : e.displayName || e.name;
+          n && (r = `
+
+Check the top-level render call using <` + n + ">.");
+        }
+        return r;
+      }
+    }
+    function xe(e, r) {
+      {
+        if (!e._store || e._store.validated || e.key != null)
+          return;
+        e._store.validated = !0;
+        var n = sr(r);
+        if (me[n])
+          return;
+        me[n] = !0;
+        var o = "";
+        e && e._owner && e._owner !== X.current && (o = " It was passed a child from " + w(e._owner.type) + "."), V(e), E('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', n, o), V(null);
+      }
+    }
+    function ye(e, r) {
+      {
+        if (typeof e != "object")
+          return;
+        if (z(e))
+          for (var n = 0; n < e.length; n++) {
+            var o = e[n];
+            Z(o) && xe(o, r);
+          }
+        else if (Z(e))
+          e._store && (e._store.validated = !0);
+        else if (e) {
+          var f = Ve(e);
+          if (typeof f == "function" && f !== e.entries)
+            for (var c = f.call(e), u; !(u = c.next()).done; )
+              Z(u.value) && xe(u.value, r);
+        }
+      }
+    }
+    function ur(e) {
+      {
+        var r = e.type;
+        if (r == null || typeof r == "string")
+          return;
+        var n;
+        if (typeof r == "function")
+          n = r.propTypes;
+        else if (typeof r == "object" && (r.$$typeof === d || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        r.$$typeof === C))
+          n = r.propTypes;
+        else
+          return;
+        if (n) {
+          var o = w(r);
+          Ge(n, e.props, "prop", o, e);
+        } else if (r.PropTypes !== void 0 && !H) {
+          H = !0;
+          var f = w(r);
+          E("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", f || "Unknown");
+        }
+        typeof r.getDefaultProps == "function" && !r.getDefaultProps.isReactClassApproved && E("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function lr(e) {
+      {
+        for (var r = Object.keys(e.props), n = 0; n < r.length; n++) {
+          var o = r[n];
+          if (o !== "children" && o !== "key") {
+            V(e), E("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", o), V(null);
+            break;
+          }
+        }
+        e.ref !== null && (V(e), E("Invalid attribute `ref` supplied to `React.Fragment`."), V(null));
+      }
+    }
+    var Se = {};
+    function Te(e, r, n, o, f, c) {
+      {
+        var u = ke(e);
+        if (!u) {
+          var s = "";
+          (e === void 0 || typeof e == "object" && e !== null && Object.keys(e).length === 0) && (s += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var _ = or();
+          _ ? s += _ : s += Re();
+          var p;
+          e === null ? p = "null" : z(e) ? p = "array" : e !== void 0 && e.$$typeof === t ? (p = "<" + (w(e.type) || "Unknown") + " />", s = " Did you accidentally export a JSX literal instead of a component?") : p = typeof e, E("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", p, s);
+        }
+        var h = ir(e, r, n, f, c);
+        if (h == null)
+          return h;
+        if (u) {
+          var O = r.children;
+          if (O !== void 0)
+            if (o)
+              if (z(O)) {
+                for (var I = 0; I < O.length; I++)
+                  ye(O[I], e);
+                Object.freeze && Object.freeze(O);
+              } else
+                E("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              ye(O, e);
+        }
+        if (D.call(r, "key")) {
+          var F = w(e), x = Object.keys(r).filter(function(gr) {
+            return gr !== "key";
+          }), Q = x.length > 0 ? "{key: someKey, " + x.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Se[F + Q]) {
+            var pr = x.length > 0 ? "{" + x.join(": ..., ") + ": ...}" : "{}";
+            E(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, Q, F, pr, F), Se[F + Q] = !0;
+          }
+        }
+        return e === a ? lr(h) : ur(h), h;
+      }
+    }
+    function fr(e, r, n) {
+      return Te(e, r, n, !0);
+    }
+    function cr(e, r, n) {
+      return Te(e, r, n, !1);
+    }
+    var dr = cr, vr = fr;
+    Y.Fragment = a, Y.jsx = dr, Y.jsxs = vr;
+  }()), Y;
+}
+var Pe;
+function mr() {
+  return Pe || (Pe = 1, process.env.NODE_ENV === "production" ? q.exports = _r() : q.exports = Rr()), q.exports;
+}
+var xr = mr();
+const Ae = hr(void 0), wr = ({ children: l, scopeName: t }) => (t || (t = br(() => Math.random().toString(36).substring(2, 15), [])), /* @__PURE__ */ xr.jsx(Ae.Provider, { value: { scopeName: t }, children: l })), yr = () => Er(Ae);
+class g {
+  data = /* @__PURE__ */ new Map();
+  defaultValue() {
+    return {};
+  }
+  addListener(t, i, a) {
+    this.data.has(g.prefix(t, i)) || this.data.set(g.prefix(t, i), {
+      ...this.defaultValue,
+      listeners: []
+    }), this.data.get(g.prefix(t, i)).listeners.push(a);
+  }
+  removeListener(t, i, a) {
+    this.data.has(g.prefix(t, i)) && (this.data.get(g.prefix(t, i)).listeners = this.data.get(g.prefix(t, i)).listeners.filter((b) => b !== a));
+  }
+  callListeners(t, i) {
+    this.data.has(g.prefix(t, i)) && this.data.get(g.prefix(t, i)).listeners.forEach((a) => a());
+  }
+  init(t, i, a) {
+    this.data.has(g.prefix(t, i)) || this.data.set(g.prefix(t, i), {
+      ...a,
+      listeners: []
+    });
+  }
+  clearAll(t = !1) {
+    t || this.data.forEach((i) => {
+      i.listeners.forEach((a) => a());
+    }), this.data.clear();
+  }
+  clear(t, i, a = !1) {
+    a || this.callListeners(t, i), this.data.delete(g.prefix(t, i));
+  }
+  get(t, i) {
+    let a = this.has(t, i);
+    if (a)
+      return this.data.get(a);
+  }
+  setValue(t, i, a) {
+    this.data.has(g.prefix(t, i)) && this.data.set(g.prefix(t, i), {
+      ...this.data.get(g.prefix(t, i)),
+      ...a
+    });
+  }
+  has(t, i) {
+    return this.data.has(g.prefix(t, i)) ? g.prefix(t, i) : this.data.has(g.prefix(t, "_global")) ? g.prefix(t, "_global") : void 0;
+  }
+  static prefix(t, i) {
+    return `${i}_${t}`;
+  }
+}
+const Fe = (l) => {
+  const t = yr();
+  return {
+    prefix: l ?? t?.scopeName ?? "_global"
+  };
+};
+class Sr extends g {
+  defaultValue() {
+    return { value: void 0 };
+  }
+  init(t, i, a) {
+    super.init(t, i, { value: a });
+  }
+  setValue(t, i, a) {
+    super.setValue(t, i, { value: a });
+  }
+}
+class Tr {
+  get(t, i = "_global") {
+    const a = i || "_global";
+    return y.get(t, a)?.value;
+  }
+  set(t, i, a = "_global") {
+    const b = a || "_global";
+    y.setValue(t, b, { value: i });
+  }
+  clearAll() {
+    y.clearAll();
+  }
+  clear(t, i = "_global") {
+    const a = i || "_global";
+    y.clear(t, a);
+  }
+  has(t, i = "_global") {
+    const a = i || "_global";
+    return !!y.has(t, a);
+  }
+  getAll() {
+    return y.data;
+  }
+}
+const jr = new Tr(), y = new Sr(), Ar = (l, t, i) => {
+  const { prefix: a } = Fe(i);
+  y.init(l, a, t);
+  const b = je((v) => (y.init(l, a, t), y.addListener(l, a, v), () => {
+    y.removeListener(l, a, v);
+  }), () => y.get(l, a)?.value);
+  return [
+    b,
+    (v) => {
+      const T = typeof v == "function" ? v(y.get(l, a)?.value) : v;
+      T !== b && (y.setValue(l, a, T), y.callListeners(l, a));
+    }
+  ];
+};
+class Or extends g {
+  defaultValue() {
+    return {
+      fnState: {
+        results: void 0,
+        isLoading: !1,
+        error: void 0
+      }
+    };
+  }
+  init(t, i) {
+    super.init(t, i, this.defaultValue());
+  }
+  setValue(t, i, a) {
+    super.setValue(t, i, a);
+  }
+}
+class Cr {
+  get(t, i = "_global") {
+    const a = i || "_global";
+    return R.get(t, a)?.fnState;
+  }
+  set(t, i, a = "_global") {
+    const b = a || "_global";
+    R.setValue(t, b, i);
+  }
+  clearAll() {
+    R.clearAll();
+  }
+  clear(t, i = "_global") {
+    const a = i || "_global";
+    R.clear(t, a);
+  }
+  has(t, i = "_global") {
+    const a = i || "_global";
+    return !!R.has(t, a);
+  }
+  getAll() {
+    return R.data;
+  }
+}
+const Fr = new Cr(), R = new Or(), Lr = (l, t, i) => {
+  const { prefix: a } = Fe(i);
+  R.init(l, a);
+  const b = je((v) => (R.init(l, a), R.addListener(l, a, v), () => {
+    R.removeListener(l, a, v);
+  }), () => R.get(l, a).fnState), P = async (v, ...T) => {
+    const d = R.get(l, a);
+    if (!v && (d.fnState.isLoading || d.fnState.results !== void 0)) return d.fnState;
+    d.fnState = { ...d.fnState, isLoading: !0, error: void 0 }, console.log(R.get(l, a)?.fnState.isLoading), d.listeners.forEach((m) => m());
+    try {
+      const m = await t(...T);
+      d.fnState = { results: m, isLoading: !1, error: void 0 };
+    } catch (m) {
+      d.fnState = { ...d.fnState, isLoading: !1, error: m };
+    }
+    d.listeners.forEach((m) => m());
+  };
+  return {
+    state: b,
+    trigger: (...v) => {
+      P(!1, ...v);
+    },
+    forceTrigger: (...v) => {
+      P(!0, ...v);
+    },
+    clear: () => {
+      R.clear(l, a), R.init(l, a);
+    }
+  };
+};
+export {
+  wr as SharedStatesProvider,
+  Fr as sharedFunctionsApi,
+  jr as sharedStatesApi,
+  Lr as useSharedFunction,
+  Ar as useSharedState
+};