state-decorator 7.0.0-beta.0 → 7.0.0-beta.10-dev

package/index.js

@@ -1,2 +1,1045 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var r,e=require("react"),n=require("./impl"),t=function(){return(t=Object.assign||function(r){for(var e,n=1,t=arguments.length;n<t;n++)for(var u in e=arguments[n])Object.prototype.hasOwnProperty.call(e,u)&&(r[u]=e[u]);return r}).apply(this,arguments)};function u(r,e,n){if(n||2===arguments.length)for(var t,u=0,o=e.length;u<o;u++)!t&&u in e||(t||(t=Array.prototype.slice.call(e,0,u)),t[u]=e[u]);return r.concat(t||Array.prototype.slice.call(e))}function o(r,e,o,c){void 0===o&&(o={}),void 0===c&&(c=null);var i=n.createRef(),l=n.createRef(),a=n.createRef(),f=n.createRef(),s=n.createRef(),d=n.createRef(),p=n.createRef(),v=n.createRef(),g=n.createRef(),y=n.createRef(!1),R=n.createRef([]),b={},A=0;function E(r,e){var n=t(t({},r),e),u=t(t(t({},n),f.current),{isLoading:P,abortAction:m,loading:h(),loadingMap:x(),errorMap:j()});Object.keys(b).forEach((function(r){b[r](u)}))}function M(r){i.current=r,n.computeDerivedValues(i,a,l,o),E(i.current,l.current.state)}function S(t){var u;if(!y.current){a.current=t,y.current=!0,i.current=r(t);var b=new Set(null==o?void 0:o.initialActionsMarkedLoading);d.current=Object.keys(e).reduce((function(r,e){var t;return r[e]=b.has(e)?((t={})[n.DEFAULT_PROMISE_ID]=!0,t):{},r}),{}),p.current=Object.keys(e).reduce((function(r,e){return r[e]={},r}),{}),s.current={},v.current={},g.current={},l.current={state:null,deps:{}},R.current=[];var A={options:o,get state(){return i.current},actions:e,setState:M},S=function(r){var e,n=r();R.current.push(n),null===(e=n.init)||void 0===e||e.call(n,A)};null===(u=n.globalConfig.defaultMiddlewares)||void 0===u||u.forEach(S),null==c||c.forEach(S),n.computeDerivedValues(i,a,l,o),n.onPropChange(i,l,a,null,f,o,L,!0),(null==o?void 0:o.onMount)&&o.onMount(n.buildOnMountInvocationContext(i,l,a,f)),E(i.current,l.current.state)}}function L(r,e,t,u,c,f,s,p){void 0===s&&(s=!1),void 0===p&&(p=!1);var v=!1;if(y.current){var g=e,b=!!c&&n.isLoadingImpl(g||d.current,[t,null==f?void 0:f.promiseId]),A=n.runMiddlewares(R.current,i.current,r,b,t,u,c,f),M=A.newState,S=A.newLoading;if(null!=M&&(v=!0,i.current=M),b!==S&&(g=n.buildLoadingMap(g,t,(null==f?void 0:f.promiseId)||n.DEFAULT_PROMISE_ID,S),0===Object.keys(g).length&&(g=void 0)),null!=g&&(v=!0,d.current=g),v)n.computeDerivedValues(i,a,l,o),p||E(M||i.current,l.current.state);else if(s){n.computeDerivedValues(i,a,l,o)&&!p&&E(M||i.current,l.current.state)}}}var O=Object.keys(e);function P(){for(var r=[],e=0;e<arguments.length;e++)r[e]=arguments[e];return n.isLoadingImpl.apply(void 0,u([d.current],r,!1))}function m(r,e){var t,u;void 0===e&&(e=n.DEFAULT_PROMISE_ID);var o=null===(u=null===(t=v.current[r])||void 0===t?void 0:t[e])||void 0===u?void 0:u.abortController,c=!1;return o&&(o.abort(),c=!0),c}function h(){if(y.current){var r=d.current;return null!=Object.keys(r).find((function(e){var n=r[e];return Object.keys(n).find((function(r){return!!n[r]}))}))}return null}function x(){if(y.current){var r=d.current;return Object.keys(r).reduce((function(e,n){var t=r[n];return e[n]=null!=Object.keys(t).find((function(r){return!!t[r]})),e}),{})}return null}function j(){return y.current?n.buildErrorMap(p.current):null}return f.current=O.reduce((function(r,t){var u=e[t];return n.isSimpleSyncAction(u)?r[t]=n.decorateSimpleSyncAction(t,u,i,l,a,y,L):n.isAsyncAction(u)?r[t]=n.decorateAsyncAction({actionName:t,stateRef:i,derivedStateRef:l,propsRef:a,loadingMapRef:d,errorMapRef:p,actionsRef:f,promisesRef:v,conflictActionsRef:g,initializedRef:y,options:o,setState:L,action:n.computeAsyncActionInput(u)}):n.isSyncAction(u)&&(r[t]=n.decorateSyncAction(t,u,i,l,a,f,y,s,o,L)),r}),{}),{getConfig:function(){return{getInitialState:r,options:o,actions:e}},setProps:function(r){var e=a.current;a.current=r,y.current?n.onPropChange(i,l,a,e,f,o,L,!1):S(r)},addStateListener:function(r){var e="".concat(A++);return b[e]=r,function(){delete b[e]}},init:S,destroy:function(){var r;y.current&&(null===(r=null==o?void 0:o.onUnmount)||void 0===r||r.call(o,n.buildOnMountInvocationContext(i,l,a,f)),a.current=null,i.current=null,d.current=null,p.current=null,v.current=null,g.current=null,l.current=null,Object.keys(s.current).forEach((function(r){clearTimeout(s.current[r])})),s.current=null,b={},y.current=!1,R.current.forEach((function(r){var e;null===(e=r.destroy)||void 0===e||e.call(r)})),R.current=[])},isLoading:P,abortAction:m,get actions(){return f.current},get state(){return y.current?t(t({},i.current),l.current.state):null},get loading(){return h()},get loadingMap(){return x()},get errorMap(){return j()},get loadingParallelMap(){return y.current?d.current:null},get errorParallelMap(){return y.current?p.current:null}}}function c(r,u,o){var c=e.useReducer((function(r){return r>100?0:r+1}),0)[1],i=e.useMemo((function(){return u instanceof Function?u:function(r){return a(r,u)}}),[u]),l=e.useMemo((function(){return function(r){return null!=o&&o.length>0?a(r.loadingMap,o):null}}),[o]),f=e.useRef(null),s=e.useRef(null);if(null===f.current){var d=t(t(t({},r.state),r.actions),a(r,["actions","loading","isLoading","abortAction","loadingMap","errorMap"]));f.current=i(d),s.current=l(d)}e.useLayoutEffect((function(){return r.addStateListener((function(r){var e,t=i(r),u=l(r),o=f.current,a=n.globalConfig.comparator;e=null==o||!a(t,o)||!a(u,s.current),f.current=t,s.current=u,e&&c()}))}),[]);var p=f.current,v=s.current;return null==v?p:t(t({},p),{loadingMap:v})}function i(r,n,t){void 0===n&&(n=null),void 0===t&&(t=!0);var u=e.useReducer((function(r){return r>100?0:r+1}),0)[1],o=e.useRef(r);return r.setProps(n),e.useLayoutEffect((function(){t&&o.current.addStateListener((function(){u()}))}),[t]),r}function l(r,n,t,u,c,l){void 0===l&&(l=!0);var a=e.useRef();return null==a.current&&(a.current=o(r,n,u,c)),e.useEffect((function(){return function(){var r;null===(r=a.current)||void 0===r||r.destroy()}}),[]),i(a.current,t,l)}function a(r,e){return e.reduce((function(e,n){return r.hasOwnProperty(n)&&(e[n]=r[n]),e}),{})}exports.ConflictPolicy=void 0,(r=exports.ConflictPolicy||(exports.ConflictPolicy={})).REJECT="reject",r.IGNORE="ignore",r.KEEP_LAST="keepLast",r.KEEP_ALL="keepAll",r.PARALLEL="parallel",r.REUSE="reuse",Object.defineProperty(exports,"ParallelActionError",{enumerable:!0,get:function(){return n.ParallelActionError}}),Object.defineProperty(exports,"setGlobalConfig",{enumerable:!0,get:function(){return n.setGlobalConfig}}),exports.createStore=o,exports.default=l,exports.pick=a,exports.slice=function(){for(var r=[],e=0;e<arguments.length;e++)r[e]=arguments[e];return function(e){return a(e,r)}},exports.useLocalStore=l,exports.useStore=i,exports.useStoreContextSlice=function(r,n,t){return c(e.useContext(r),n,t)},exports.useStoreSlice=c;
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var e = require('react');
+var impl = require('./impl');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var e__default = /*#__PURE__*/_interopDefaultLegacy(e);
+
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __spreadArray(to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+}
+
+function createCommonjsModule(fn) {
+  var module = { exports: {} };
+	return fn(module, module.exports), module.exports;
+}
+
+/**
+ * @license React
+ * use-sync-external-store-shim.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.
+ */
+function h(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var k="function"===typeof Object.is?Object.is:h,l=e__default['default'].useState,m=e__default['default'].useEffect,n=e__default['default'].useLayoutEffect,p$1=e__default['default'].useDebugValue;function q$1(a,b){var d=b(),f=l({inst:{value:d,getSnapshot:b}}),c=f[0].inst,g=f[1];n(function(){c.value=d;c.getSnapshot=b;r$1(c)&&g({inst:c});},[a,d,b]);m(function(){r$1(c)&&g({inst:c});return a(function(){r$1(c)&&g({inst:c});})},[a]);p$1(d);return d}
+function r$1(a){var b=a.getSnapshot;a=a.value;try{var d=b();return !k(a,d)}catch(f){return !0}}function t$1(a,b){return b()}var u$1="undefined"===typeof window||"undefined"===typeof window.document||"undefined"===typeof window.document.createElement?t$1:q$1;var useSyncExternalStore=void 0!==e__default['default'].useSyncExternalStore?e__default['default'].useSyncExternalStore:u$1;
+
+var useSyncExternalStoreShim_production_min = {
+	useSyncExternalStore: useSyncExternalStore
+};
+
+/**
+ * @license React
+ * use-sync-external-store-shim.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 useSyncExternalStoreShim_development = createCommonjsModule(function (module, exports) {
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+}
+          var React = e__default['default'];
+
+var ReactSharedInternals = React.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+
+function error(format) {
+  {
+    {
+      for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        args[_key2 - 1] = arguments[_key2];
+      }
+
+      printWarning('error', format, args);
+    }
+  }
+}
+
+function printWarning(level, format, args) {
+  // When changing this logic, you might want to also
+  // update consoleWithStackDev.www.js as well.
+  {
+    var ReactDebugCurrentFrame = ReactSharedInternals.ReactDebugCurrentFrame;
+    var stack = ReactDebugCurrentFrame.getStackAddendum();
+
+    if (stack !== '') {
+      format += '%s';
+      args = args.concat([stack]);
+    } // eslint-disable-next-line react-internal/safe-string-coercion
+
+
+    var argsWithFormat = args.map(function (item) {
+      return String(item);
+    }); // Careful: RN currently depends on this prefix
+
+    argsWithFormat.unshift('Warning: ' + format); // We intentionally don't use spread (or .apply) directly because it
+    // breaks IE9: https://github.com/facebook/react/issues/13610
+    // eslint-disable-next-line react-internal/no-production-logging
+
+    Function.prototype.apply.call(console[level], console, argsWithFormat);
+  }
+}
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+// dispatch for CommonJS interop named imports.
+
+var useState = React.useState,
+    useEffect = React.useEffect,
+    useLayoutEffect = React.useLayoutEffect,
+    useDebugValue = React.useDebugValue;
+var didWarnOld18Alpha = false;
+var didWarnUncachedGetSnapshot = false; // Disclaimer: This shim breaks many of the rules of React, and only works
+// because of a very particular set of implementation details and assumptions
+// -- change any one of them and it will break. The most important assumption
+// is that updates are always synchronous, because concurrent rendering is
+// only available in versions of React that also have a built-in
+// useSyncExternalStore API. And we only use this shim when the built-in API
+// does not exist.
+//
+// Do not assume that the clever hacks used by this hook also work in general.
+// The point of this shim is to replace the need for hacks by other libraries.
+
+function useSyncExternalStore(subscribe, getSnapshot, // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+// React do not expose a way to check if we're hydrating. So users of the shim
+// will need to track that themselves and return the correct value
+// from `getSnapshot`.
+getServerSnapshot) {
+  {
+    if (!didWarnOld18Alpha) {
+      if (React.startTransition !== undefined) {
+        didWarnOld18Alpha = true;
+
+        error('You are using an outdated, pre-release alpha of React 18 that ' + 'does not support useSyncExternalStore. The ' + 'use-sync-external-store shim will not work correctly. Upgrade ' + 'to a newer pre-release.');
+      }
+    }
+  } // Read the current snapshot from the store on every render. Again, this
+  // breaks the rules of React, and only works here because of specific
+  // implementation details, most importantly that updates are
+  // always synchronous.
+
+
+  var value = getSnapshot();
+
+  {
+    if (!didWarnUncachedGetSnapshot) {
+      var cachedValue = getSnapshot();
+
+      if (!objectIs(value, cachedValue)) {
+        error('The result of getSnapshot should be cached to avoid an infinite loop');
+
+        didWarnUncachedGetSnapshot = true;
+      }
+    }
+  } // Because updates are synchronous, we don't queue them. Instead we force a
+  // re-render whenever the subscribed state changes by updating an some
+  // arbitrary useState hook. Then, during render, we call getSnapshot to read
+  // the current value.
+  //
+  // Because we don't actually use the state returned by the useState hook, we
+  // can save a bit of memory by storing other stuff in that slot.
+  //
+  // To implement the early bailout, we need to track some things on a mutable
+  // object. Usually, we would put that in a useRef hook, but we can stash it in
+  // our useState hook instead.
+  //
+  // To force a re-render, we call forceUpdate({inst}). That works because the
+  // new object always fails an equality check.
+
+
+  var _useState = useState({
+    inst: {
+      value: value,
+      getSnapshot: getSnapshot
+    }
+  }),
+      inst = _useState[0].inst,
+      forceUpdate = _useState[1]; // Track the latest getSnapshot function with a ref. This needs to be updated
+  // in the layout phase so we can access it during the tearing check that
+  // happens on subscribe.
+
+
+  useLayoutEffect(function () {
+    inst.value = value;
+    inst.getSnapshot = getSnapshot; // Whenever getSnapshot or subscribe changes, we need to check in the
+    // commit phase if there was an interleaved mutation. In concurrent mode
+    // this can happen all the time, but even in synchronous mode, an earlier
+    // effect may have mutated the store.
+
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceUpdate({
+        inst: inst
+      });
+    }
+  }, [subscribe, value, getSnapshot]);
+  useEffect(function () {
+    // Check for changes right before subscribing. Subsequent changes will be
+    // detected in the subscription handler.
+    if (checkIfSnapshotChanged(inst)) {
+      // Force a re-render.
+      forceUpdate({
+        inst: inst
+      });
+    }
+
+    var handleStoreChange = function () {
+      // TODO: Because there is no cross-renderer API for batching updates, it's
+      // up to the consumer of this library to wrap their subscription event
+      // with unstable_batchedUpdates. Should we try to detect when this isn't
+      // the case and print a warning in development?
+      // The store changed. Check if the snapshot changed since the last time we
+      // read from the store.
+      if (checkIfSnapshotChanged(inst)) {
+        // Force a re-render.
+        forceUpdate({
+          inst: inst
+        });
+      }
+    }; // Subscribe to the store and return a clean-up function.
+
+
+    return subscribe(handleStoreChange);
+  }, [subscribe]);
+  useDebugValue(value);
+  return value;
+}
+
+function checkIfSnapshotChanged(inst) {
+  var latestGetSnapshot = inst.getSnapshot;
+  var prevValue = inst.value;
+
+  try {
+    var nextValue = latestGetSnapshot();
+    return !objectIs(prevValue, nextValue);
+  } catch (error) {
+    return true;
+  }
+}
+
+function useSyncExternalStore$1(subscribe, getSnapshot, getServerSnapshot) {
+  // Note: The shim does not use getServerSnapshot, because pre-18 versions of
+  // React do not expose a way to check if we're hydrating. So users of the shim
+  // will need to track that themselves and return the correct value
+  // from `getSnapshot`.
+  return getSnapshot();
+}
+
+var canUseDOM = !!(typeof window !== 'undefined' && typeof window.document !== 'undefined' && typeof window.document.createElement !== 'undefined');
+
+var isServerEnvironment = !canUseDOM;
+
+var shim = isServerEnvironment ? useSyncExternalStore$1 : useSyncExternalStore;
+var useSyncExternalStore$2 = React.useSyncExternalStore !== undefined ? React.useSyncExternalStore : shim;
+
+exports.useSyncExternalStore = useSyncExternalStore$2;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+}
+        
+  })();
+}
+});
+
+var shim = createCommonjsModule(function (module) {
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = useSyncExternalStoreShim_production_min;
+} else {
+  module.exports = useSyncExternalStoreShim_development;
+}
+});
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.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.
+ */
+function p(a,b){return a===b&&(0!==a||1/a===1/b)||a!==a&&b!==b}var q="function"===typeof Object.is?Object.is:p,r=shim.useSyncExternalStore,t=e__default['default'].useRef,u=e__default['default'].useEffect,v=e__default['default'].useMemo,w=e__default['default'].useDebugValue;
+var useSyncExternalStoreWithSelector$1=function(a,b,e,l,g){var c=t(null);if(null===c.current){var f={hasValue:!1,value:null};c.current=f;}else f=c.current;c=v(function(){function a(a){if(!c){c=!0;d=a;a=l(a);if(void 0!==g&&f.hasValue){var b=f.value;if(g(b,a))return k=b}return k=a}b=k;if(q(d,a))return b;var e=l(a);if(void 0!==g&&g(b,e))return b;d=a;return k=e}var c=!1,d,k,m=void 0===e?null:e;return [function(){return a(b())},null===m?void 0:function(){return a(m())}]},[b,e,l,g]);var d=r(a,c[0],c[1]);
+u(function(){f.hasValue=!0;f.value=d;},[d]);w(d);return d};
+
+var withSelector_production_min = {
+	useSyncExternalStoreWithSelector: useSyncExternalStoreWithSelector$1
+};
+
+/**
+ * @license React
+ * use-sync-external-store-shim/with-selector.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 withSelector_development = createCommonjsModule(function (module, exports) {
+
+if (process.env.NODE_ENV !== "production") {
+  (function() {
+
+/* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(new Error());
+}
+          var React = e__default['default'];
+var shim$1 = shim;
+
+/**
+ * inlined Object.is polyfill to avoid requiring consumers ship their own
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
+ */
+function is(x, y) {
+  return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y // eslint-disable-line no-self-compare
+  ;
+}
+
+var objectIs = typeof Object.is === 'function' ? Object.is : is;
+
+var useSyncExternalStore = shim$1.useSyncExternalStore;
+
+// for CommonJS interop.
+
+var useRef = React.useRef,
+    useEffect = React.useEffect,
+    useMemo = React.useMemo,
+    useDebugValue = React.useDebugValue; // Same as useSyncExternalStore, but supports selector and isEqual arguments.
+
+function useSyncExternalStoreWithSelector(subscribe, getSnapshot, getServerSnapshot, selector, isEqual) {
+  // Use this to track the rendered snapshot.
+  var instRef = useRef(null);
+  var inst;
+
+  if (instRef.current === null) {
+    inst = {
+      hasValue: false,
+      value: null
+    };
+    instRef.current = inst;
+  } else {
+    inst = instRef.current;
+  }
+
+  var _useMemo = useMemo(function () {
+    // Track the memoized state using closure variables that are local to this
+    // memoized instance of a getSnapshot function. Intentionally not using a
+    // useRef hook, because that state would be shared across all concurrent
+    // copies of the hook/component.
+    var hasMemo = false;
+    var memoizedSnapshot;
+    var memoizedSelection;
+
+    var memoizedSelector = function (nextSnapshot) {
+      if (!hasMemo) {
+        // The first time the hook is called, there is no memoized result.
+        hasMemo = true;
+        memoizedSnapshot = nextSnapshot;
+
+        var _nextSelection = selector(nextSnapshot);
+
+        if (isEqual !== undefined) {
+          // Even if the selector has changed, the currently rendered selection
+          // may be equal to the new selection. We should attempt to reuse the
+          // current value if possible, to preserve downstream memoizations.
+          if (inst.hasValue) {
+            var currentSelection = inst.value;
+
+            if (isEqual(currentSelection, _nextSelection)) {
+              memoizedSelection = currentSelection;
+              return currentSelection;
+            }
+          }
+        }
+
+        memoizedSelection = _nextSelection;
+        return _nextSelection;
+      } // We may be able to reuse the previous invocation's result.
+
+
+      // We may be able to reuse the previous invocation's result.
+      var prevSnapshot = memoizedSnapshot;
+      var prevSelection = memoizedSelection;
+
+      if (objectIs(prevSnapshot, nextSnapshot)) {
+        // The snapshot is the same as last time. Reuse the previous selection.
+        return prevSelection;
+      } // The snapshot has changed, so we need to compute a new selection.
+
+
+      // The snapshot has changed, so we need to compute a new selection.
+      var nextSelection = selector(nextSnapshot); // If a custom isEqual function is provided, use that to check if the data
+      // has changed. If it hasn't, return the previous selection. That signals
+      // to React that the selections are conceptually equal, and we can bail
+      // out of rendering.
+
+      // If a custom isEqual function is provided, use that to check if the data
+      // has changed. If it hasn't, return the previous selection. That signals
+      // to React that the selections are conceptually equal, and we can bail
+      // out of rendering.
+      if (isEqual !== undefined && isEqual(prevSelection, nextSelection)) {
+        return prevSelection;
+      }
+
+      memoizedSnapshot = nextSnapshot;
+      memoizedSelection = nextSelection;
+      return nextSelection;
+    }; // Assigning this to a constant so that Flow knows it can't change.
+
+
+    // Assigning this to a constant so that Flow knows it can't change.
+    var maybeGetServerSnapshot = getServerSnapshot === undefined ? null : getServerSnapshot;
+
+    var getSnapshotWithSelector = function () {
+      return memoizedSelector(getSnapshot());
+    };
+
+    var getServerSnapshotWithSelector = maybeGetServerSnapshot === null ? undefined : function () {
+      return memoizedSelector(maybeGetServerSnapshot());
+    };
+    return [getSnapshotWithSelector, getServerSnapshotWithSelector];
+  }, [getSnapshot, getServerSnapshot, selector, isEqual]),
+      getSelection = _useMemo[0],
+      getServerSelection = _useMemo[1];
+
+  var value = useSyncExternalStore(subscribe, getSelection, getServerSelection);
+  useEffect(function () {
+    inst.hasValue = true;
+    inst.value = value;
+  }, [value]);
+  useDebugValue(value);
+  return value;
+}
+
+exports.useSyncExternalStoreWithSelector = useSyncExternalStoreWithSelector;
+          /* global __REACT_DEVTOOLS_GLOBAL_HOOK__ */
+if (
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' &&
+  typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop ===
+    'function'
+) {
+  __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(new Error());
+}
+        
+  })();
+}
+});
+
+var withSelector = createCommonjsModule(function (module) {
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = withSelector_production_min;
+} else {
+  module.exports = withSelector_development;
+}
+});
+
+/*! *****************************************************************************
+Copyright (c) GlobalSport SAS.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/**
+ * The State decorator can manage only one asynchronous action of same name at a time.
+ * This enum is enumertaing all the policies in such case.
+ */
+exports.ConflictPolicy = void 0;
+(function (ConflictPolicy) {
+    /**
+     * Reject the promise.
+     */
+    ConflictPolicy["REJECT"] = "reject";
+    /**
+     * Return a resolved promise with no result.
+     */
+    ConflictPolicy["IGNORE"] = "ignore";
+    /**
+     * Execute only the last call that conflicts after the one ongoing.
+     */
+    ConflictPolicy["KEEP_LAST"] = "keepLast";
+    /**
+     * Execute all calls one after another.
+     */
+    ConflictPolicy["KEEP_ALL"] = "keepAll";
+    /**
+     * Execute all calls one after another.
+     * @see getPromiseId
+     */
+    ConflictPolicy["PARALLEL"] = "parallel";
+    /**
+     * Reuse the ongoing promise if any and if possible (same arguments). Only for GET requests!
+     */
+    ConflictPolicy["REUSE"] = "reuse";
+})(exports.ConflictPolicy || (exports.ConflictPolicy = {}));
+
+var useSyncExternalStoreWithSelector = withSelector.useSyncExternalStoreWithSelector;
+// =============================
+//
+// STORE
+//
+// =============================
+/**
+ * Create a new store.
+ * @param config Store configuration
+ * @returns a store.
+ */
+function createStore(config) {
+    var stateRef = impl.createRef();
+    var derivedStateRef = impl.createRef();
+    var propsRef = impl.createRef();
+    var actionsRef = impl.createRef();
+    var timeoutRef = impl.createRef();
+    var loadingParallelMapRef = impl.createRef();
+    var loadingMapRef = impl.createRef();
+    var loadingRef = impl.createRef();
+    var errorMapRef = impl.createRef();
+    var promisesRef = impl.createRef();
+    var conflictActionsRef = impl.createRef();
+    var initializedRef = impl.createRef(false);
+    var snapshotRef = impl.createRef();
+    var middlewaresRef = impl.createRef([]);
+    var getInitialState = config.getInitialState, actionsImpl = config.actions, _a = config.middlewares, middlewares = _a === void 0 ? [] : _a, options = __rest(config, ["getInitialState", "actions", "middlewares"]);
+    var stateListeners = {};
+    var stateListenerCount = 0;
+    function addStateListener(listener) {
+        var id = "".concat(stateListenerCount++);
+        stateListeners[id] = listener;
+        return function () {
+            delete stateListeners[id];
+        };
+    }
+    function notifyStateListeners() {
+        updateSnapshot();
+        Object.keys(stateListeners).forEach(function (listenerId) {
+            stateListeners[listenerId]();
+        });
+    }
+    function setProps(p) {
+        var oldProps = propsRef.current;
+        propsRef.current = p;
+        if (!initializedRef.current) {
+            init(p);
+        }
+        else {
+            impl.onPropChange(stateRef, derivedStateRef, propsRef, oldProps, actionsRef, options, getInitialState, setState, false, false);
+        }
+    }
+    /** Middleware only: sets the internal state, recompute derived state and notify listeners */
+    function setInternalState(s) {
+        stateRef.current = s;
+        impl.computeDerivedValues(stateRef, propsRef, derivedStateRef, options);
+        notifyStateListeners();
+    }
+    function setInternalLoadingMap(map) {
+        loadingParallelMapRef.current = map;
+        loadingMapRef.current = getLoadingMap();
+        loadingRef.current = isAnyLoading();
+    }
+    function init(p) {
+        var _a;
+        if (!initializedRef.current) {
+            propsRef.current = p;
+            initializedRef.current = true;
+            stateRef.current = typeof getInitialState === 'function' ? getInitialState(p) : getInitialState;
+            var initialActionSet_1 = new Set(options === null || options === void 0 ? void 0 : options.initialActionsMarkedLoading);
+            var loadingMap = Object.keys(actionsImpl).reduce(function (acc, name) {
+                var _a;
+                acc[name] = initialActionSet_1.has(name) ? (_a = {}, _a[impl.DEFAULT_PROMISE_ID] = true, _a) : {};
+                return acc;
+            }, {});
+            setInternalLoadingMap(loadingMap);
+            errorMapRef.current = Object.keys(actionsImpl).reduce(function (acc, name) {
+                acc[name] = {};
+                return acc;
+            }, {});
+            timeoutRef.current = {};
+            promisesRef.current = {};
+            conflictActionsRef.current = {};
+            derivedStateRef.current = {
+                state: null,
+                deps: {},
+            };
+            // init middlewares
+            middlewaresRef.current = [];
+            var ctx_1 = {
+                options: options,
+                get state() {
+                    return stateRef.current;
+                },
+                actions: actionsImpl,
+                setState: setInternalState,
+            };
+            var mapper = function (m) {
+                var _a;
+                var middleware = m();
+                middlewaresRef.current.push(middleware);
+                (_a = middleware.init) === null || _a === void 0 ? void 0 : _a.call(middleware, ctx_1);
+            };
+            (_a = impl.globalConfig.defaultMiddlewares) === null || _a === void 0 ? void 0 : _a.forEach(mapper);
+            middlewares === null || middlewares === void 0 ? void 0 : middlewares.forEach(mapper);
+            // end init
+            impl.computeDerivedValues(stateRef, propsRef, derivedStateRef, options);
+            // manage PropsChange with onMount
+            impl.onPropChange(stateRef, derivedStateRef, propsRef, null, actionsRef, options, getInitialState, setState, true, false);
+            if (options === null || options === void 0 ? void 0 : options.onMount) {
+                options.onMount(impl.buildOnMountInvocationContext(stateRef, derivedStateRef, propsRef, actionsRef));
+            }
+            notifyStateListeners();
+        }
+    }
+    function clearError(actionName, promiseId) {
+        if (promiseId === void 0) { promiseId = impl.DEFAULT_PROMISE_ID; }
+        var map = errorMapRef.current[actionName];
+        if (map === null || map === void 0 ? void 0 : map[promiseId]) {
+            delete map[promiseId];
+        }
+        notifyStateListeners();
+    }
+    function invokeOnMountDeferred() {
+        // manage PropsChange with onMount
+        impl.onPropChange(stateRef, derivedStateRef, propsRef, null, actionsRef, options, getInitialState, setState, true, true);
+        if (options === null || options === void 0 ? void 0 : options.onMountDeferred) {
+            options.onMountDeferred(impl.buildOnMountInvocationContext(stateRef, derivedStateRef, propsRef, actionsRef));
+        }
+    }
+    function abortActionsOnDestroy() {
+        var abortedActions = Object.keys(actionsImpl).reduce(function (acc, actionName) {
+            var action = actionsImpl[actionName];
+            if (impl.isAsyncAction(action) && action.abortable) {
+                var map_1 = loadingParallelMapRef.current[actionName];
+                var aborted = Object.keys(map_1).reduce(function (acc, promiseId) {
+                    if (map_1[promiseId]) {
+                        // ongoing action
+                        abortAction(actionName, promiseId);
+                        acc.push(promiseId);
+                    }
+                    return acc;
+                }, []);
+                if (aborted.length > 0) {
+                    acc[actionName] = aborted;
+                }
+            }
+            return acc;
+        }, {});
+        return abortedActions;
+    }
+    function destroy() {
+        var _a;
+        if (initializedRef.current) {
+            var abortedActions = abortActionsOnDestroy();
+            (_a = options === null || options === void 0 ? void 0 : options.onUnmount) === null || _a === void 0 ? void 0 : _a.call(options, impl.buildOnUnMountInvocationContext(stateRef, derivedStateRef, propsRef, abortedActions));
+            propsRef.current = null;
+            stateRef.current = null;
+            loadingParallelMapRef.current = null;
+            loadingMapRef.current = null;
+            loadingRef.current = null;
+            errorMapRef.current = null;
+            promisesRef.current = null;
+            conflictActionsRef.current = null;
+            derivedStateRef.current = null;
+            snapshotRef.current = null;
+            Object.keys(timeoutRef.current).forEach(function (name) {
+                clearTimeout(timeoutRef.current[name]);
+            });
+            timeoutRef.current = null;
+            stateListeners = {};
+            initializedRef.current = false;
+            middlewaresRef.current.forEach(function (m) {
+                var _a;
+                (_a = m.destroy) === null || _a === void 0 ? void 0 : _a.call(m);
+            });
+            middlewaresRef.current = [];
+        }
+    }
+    function setState(newStateIn, newLoadingMapIn, actionName, actionType, isAsync, actionCtx, propsChanged, init) {
+        if (propsChanged === void 0) { propsChanged = false; }
+        if (init === void 0) { init = false; }
+        var hasChanged = false;
+        if (!initializedRef.current) {
+            return;
+        }
+        var newLoadingMap = newLoadingMapIn;
+        var oldLoading = isAsync
+            ? impl.isLoadingImpl(newLoadingMap || loadingParallelMapRef.current, [actionName, actionCtx === null || actionCtx === void 0 ? void 0 : actionCtx.promiseId])
+            : false;
+        var _a = impl.runMiddlewares(middlewaresRef.current, stateRef.current, newStateIn, oldLoading, actionName, actionType, isAsync, actionCtx), newState = _a.newState, newLoading = _a.newLoading;
+        if (newState != null) {
+            hasChanged = true;
+            stateRef.current = newState;
+        }
+        if (oldLoading !== newLoading) {
+            newLoadingMap = impl.buildLoadingMap(newLoadingMap, actionName, (actionCtx === null || actionCtx === void 0 ? void 0 : actionCtx.promiseId) || impl.DEFAULT_PROMISE_ID, newLoading);
+            if (Object.keys(newLoadingMap).length === 0) {
+                newLoadingMap = undefined;
+            }
+        }
+        if (newLoadingMap != null) {
+            hasChanged = true;
+            setInternalLoadingMap(newLoadingMap);
+        }
+        if (hasChanged) {
+            impl.computeDerivedValues(stateRef, propsRef, derivedStateRef, options);
+            if (!init) {
+                stateRef.current = newState || stateRef.current;
+                notifyStateListeners();
+            }
+        }
+        else if (propsChanged) {
+            var derivedChanged = impl.computeDerivedValues(stateRef, propsRef, derivedStateRef, options);
+            if (derivedChanged && !init) {
+                notifyStateListeners();
+            }
+        }
+    }
+    var keys = Object.keys(actionsImpl);
+    actionsRef.current = keys.reduce(function (acc, actionName) {
+        var action = actionsImpl[actionName];
+        if (impl.isSimpleSyncAction(action)) {
+            acc[actionName] = impl.decorateSimpleSyncAction(actionName, action, stateRef, derivedStateRef, propsRef, initializedRef, setState);
+        }
+        else if (impl.isAsyncAction(action)) {
+            acc[actionName] = impl.decorateAsyncAction({
+                actionName: actionName,
+                stateRef: stateRef,
+                derivedStateRef: derivedStateRef,
+                propsRef: propsRef,
+                loadingParallelMapRef: loadingParallelMapRef,
+                errorMapRef: errorMapRef,
+                actionsRef: actionsRef,
+                promisesRef: promisesRef,
+                conflictActionsRef: conflictActionsRef,
+                initializedRef: initializedRef,
+                options: options,
+                setState: setState,
+                clearError: clearError,
+                action: impl.computeAsyncActionInput(action),
+            });
+        }
+        else if (impl.isSyncAction(action)) {
+            acc[actionName] = impl.decorateSyncAction(actionName, action, stateRef, derivedStateRef, propsRef, actionsRef, initializedRef, timeoutRef, options, setState, clearError);
+        }
+        return acc;
+    }, {});
+    function isLoading() {
+        var props = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            props[_i] = arguments[_i];
+        }
+        return impl.isLoadingImpl.apply(void 0, __spreadArray([loadingParallelMapRef.current], props, false));
+    }
+    function abortAction(actionName, promiseId) {
+        var _a, _b;
+        if (promiseId === void 0) { promiseId = impl.DEFAULT_PROMISE_ID; }
+        var abortController = (_b = (_a = promisesRef.current[actionName]) === null || _a === void 0 ? void 0 : _a[promiseId]) === null || _b === void 0 ? void 0 : _b.abortController;
+        var res = false;
+        if (abortController) {
+            abortController.abort();
+            res = true;
+        }
+        return res;
+    }
+    function isAnyLoading() {
+        if (initializedRef.current) {
+            var loadingMap_1 = loadingParallelMapRef.current;
+            return (Object.keys(loadingMap_1).find(function (actionName) {
+                var promises = loadingMap_1[actionName];
+                return Object.keys(promises).find(function (pId) { return !!promises[pId]; });
+            }) != null);
+        }
+        return null;
+    }
+    function getLoadingMap() {
+        if (initializedRef.current) {
+            var map_2 = loadingParallelMapRef.current;
+            var keys_1 = Object.keys(map_2);
+            return keys_1.reduce(function (acc, actionName) {
+                var subMap = map_2[actionName];
+                acc[actionName] = Object.keys(subMap).find(function (pId) { return !!subMap[pId]; }) != null;
+                return acc;
+            }, {});
+        }
+        return null;
+    }
+    function getErrorMap() {
+        if (initializedRef.current) {
+            return impl.buildErrorMap(errorMapRef.current);
+        }
+        return null;
+    }
+    function getConfig() {
+        return __assign({}, config);
+    }
+    function updateSnapshot() {
+        snapshotRef.current = __assign(__assign(__assign(__assign({}, actionsRef.current), stateRef.current), derivedStateRef.current.state), { isLoading: isLoading, abortAction: abortAction, loading: loadingRef.current, loadingMap: loadingMapRef.current, loadingParallelMap: loadingParallelMapRef.current, errorMap: getErrorMap(), errorParallelMap: errorMapRef.current });
+    }
+    function getSnapshot() {
+        return snapshotRef.current;
+    }
+    return {
+        getConfig: getConfig,
+        setProps: setProps,
+        addStateListener: addStateListener,
+        init: init,
+        destroy: destroy,
+        isLoading: isLoading,
+        abortAction: abortAction,
+        clearError: clearError,
+        getSnapshot: getSnapshot,
+        invokeOnMountDeferred: invokeOnMountDeferred,
+        get actions() {
+            return actionsRef.current;
+        },
+        get state() {
+            if (initializedRef.current) {
+                return __assign(__assign({}, stateRef.current), derivedStateRef.current.state);
+            }
+            return null;
+        },
+        get loading() {
+            return loadingRef.current;
+        },
+        get loadingMap() {
+            return loadingMapRef.current;
+        },
+        get errorMap() {
+            return getErrorMap();
+        },
+        get loadingParallelMap() {
+            if (initializedRef.current) {
+                return loadingParallelMapRef.current;
+            }
+            return null;
+        },
+        get errorParallelMap() {
+            if (initializedRef.current) {
+                return errorMapRef.current;
+            }
+            return null;
+        },
+    };
+}
+function useStoreSlice(store, funcOrArr) {
+    var slicerFunc = e.useMemo(function () { return (funcOrArr instanceof Function ? funcOrArr : function (ctx) { return pick(ctx, funcOrArr); }); }, [funcOrArr]);
+    return useSyncExternalStoreWithSelector(store.addStateListener, store.getSnapshot, store.getSnapshot, slicerFunc, impl.globalConfig.comparator);
+}
+function useStoreContextSlice(storeContext, funcOrArr) {
+    var store = e.useContext(storeContext);
+    return useStoreSlice(store, funcOrArr);
+}
+/**
+ * Binds the store to this component.
+ * Store will NOT be destroyed when component is unmouted.
+ * Props passed to actions will come from this components.
+ * If store is configured to react of props changes, it will used passed props.
+ * The component will be refreshed for every change in the store.
+ *
+ * @param store The store to listen to.
+ * @param props The parent component props
+ * @param refreshOnUpdate Whether refresh the component if store state changes.
+ * @returns The store.
+ */
+function useStore(store, props, refreshOnUpdate) {
+    if (props === void 0) { props = null; }
+    if (refreshOnUpdate === void 0) { refreshOnUpdate = true; }
+    var _a = e.useReducer(function (s) { return (s > 100 ? 0 : s + 1); }, 0), forceRefresh = _a[1];
+    var storeRef = e.useRef(store);
+    store.setProps(props);
+    e.useLayoutEffect(function () {
+        // In development mode, React is calling in order:
+        // - render
+        // - useLayoutEffect
+        // - useEffect
+        // - useLayoutEffect => delete callback
+        // - useEffect => delete callback
+        // - useLayoutEffect
+        // - useEffect
+        //
+        // Here we enforce a initialization of the store after a destroy in the useEffect delete callback
+        store.init(props);
+    }, []);
+    e.useLayoutEffect(function () {
+        if (refreshOnUpdate) {
+            return storeRef.current.addStateListener(function () {
+                forceRefresh();
+            });
+        }
+        return undefined;
+    }, [refreshOnUpdate]);
+    return store;
+}
+/**
+ * Creates and manages a local store.
+ * The component will be refreshed for every change in the store.
+ * Store will NOT be destroyed when component is unmouted.
+ *
+ * @param getInitialState Function to compute initial state from props.
+ * @param actionImpl Actions implementation.
+ * @param props Owner component props to update state or react on prop changes
+ * @param options The store options.
+ * @param refreshOnUpdate Whether refresh the component if store state changes.
+ * @returns The state, actions and isLoading function.
+ */
+function useLocalStore(config, props, refreshOnUpdate) {
+    if (refreshOnUpdate === void 0) { refreshOnUpdate = true; }
+    var storeRef = e.useRef();
+    if (storeRef.current == null) {
+        storeRef.current = createStore(config);
+    }
+    e.useEffect(function () {
+        storeRef.current.invokeOnMountDeferred();
+        return function () {
+            var _a;
+            (_a = storeRef.current) === null || _a === void 0 ? void 0 : _a.destroy();
+        };
+    }, []);
+    return useStore(storeRef.current, props, refreshOnUpdate);
+}
+// ------------- UTILS
+/**
+ * Creates a new object by picking properties to the object passed a first parameter
+ * @param obj Object to pick properties from
+ * @param props Property names
+ * @returns a new object containing only picked properties
+ */
+function pick(obj, props) {
+    return props.reduce(function (acc, p) {
+        if (obj.hasOwnProperty(p)) {
+            acc[p] = obj[p];
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Returns a function that creates a new object by picking properties to the object passed as first parameter.
+ * To be used in conjunction of <code>useStoreSlice</code> like in example:
+ *   const s = useStoreSlice(myStore, slice('list', 'addItem'));
+ * @param props Property names
+ * @returns a function to pick property from an passed object.
+ */
+function slice() {
+    var props = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        props[_i] = arguments[_i];
+    }
+    return function (store) { return pick(store, props); };
+}
+
+Object.defineProperty(exports, 'EffectError', {
+    enumerable: true,
+    get: function () {
+        return impl.EffectError;
+    }
+});
+Object.defineProperty(exports, 'ParallelActionError', {
+    enumerable: true,
+    get: function () {
+        return impl.ParallelActionError;
+    }
+});
+Object.defineProperty(exports, 'setGlobalConfig', {
+    enumerable: true,
+    get: function () {
+        return impl.setGlobalConfig;
+    }
+});
+exports.createStore = createStore;
+exports.default = useLocalStore;
+exports.pick = pick;
+exports.slice = slice;
+exports.useLocalStore = useLocalStore;
+exports.useStore = useStore;
+exports.useStoreContextSlice = useStoreContextSlice;
+exports.useStoreSlice = useStoreSlice;
 //# sourceMappingURL=index.js.map