@startlibs/core 1.0.1 → 1.0.3

package/lib/index.js

@@ -1,90 +1,48 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _classCallCheck = require('@babel/runtime/helpers/classCallCheck');
-var _createClass = require('@babel/runtime/helpers/createClass');
-var _possibleConstructorReturn = require('@babel/runtime/helpers/possibleConstructorReturn');
-var _getPrototypeOf = require('@babel/runtime/helpers/getPrototypeOf');
-var _inherits = require('@babel/runtime/helpers/inherits');
-var _debounce = require('lodash/fp/debounce');
-var React = require('react');
-var utils = require('@startlibs/utils');
-var core = require('@startlibs/core');
-var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
-var _toConsumableArray = require('@babel/runtime/helpers/toConsumableArray');
-var _set = require('lodash/fp/set');
-var _update = require('lodash/fp/update');
-var _isFunction = require('lodash/fp/isFunction');
-var _get = require('lodash/fp/get');
-var _isArray = require('lodash/fp/isArray');
-var _isString = require('lodash/fp/isString');
-var _objectDestructuringEmpty = require('@babel/runtime/helpers/objectDestructuringEmpty');
-var _objectSpread = require('@babel/runtime/helpers/objectSpread');
-var _extends = require('@babel/runtime/helpers/extends');
-var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
-var _unset = require('lodash/fp/unset');
-var _uniqueId = require('lodash/fp/uniqueId');
-var _differenceBy = require('lodash/fp/differenceBy');
-var _findIndex = require('lodash/fp/findIndex');
-var _isFinite = require('lodash/fp/isFinite');
-var _max = require('lodash/fp/max');
-var _flatMap = require('lodash/fp/flatMap');
-var _without = require('lodash/fp/without');
-var _union = require('lodash/fp/union');
-var _flow = require('lodash/fp/flow');
-var ReactDOM = require('react-dom');
-var styled = require('styled-components');
-var _defineProperty = require('@babel/runtime/helpers/defineProperty');
-var mitt = require('mitt');
-var _typeof = require('@babel/runtime/helpers/typeof');
-var _regeneratorRuntime = require('@babel/runtime/regenerator');
-var _asyncToGenerator = require('@babel/runtime/helpers/asyncToGenerator');
-var _identity = require('lodash/fp/identity');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _classCallCheck__default = /*#__PURE__*/_interopDefaultLegacy(_classCallCheck);
-var _createClass__default = /*#__PURE__*/_interopDefaultLegacy(_createClass);
-var _possibleConstructorReturn__default = /*#__PURE__*/_interopDefaultLegacy(_possibleConstructorReturn);
-var _getPrototypeOf__default = /*#__PURE__*/_interopDefaultLegacy(_getPrototypeOf);
-var _inherits__default = /*#__PURE__*/_interopDefaultLegacy(_inherits);
-var _debounce__default = /*#__PURE__*/_interopDefaultLegacy(_debounce);
-var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-var _slicedToArray__default = /*#__PURE__*/_interopDefaultLegacy(_slicedToArray);
-var _toConsumableArray__default = /*#__PURE__*/_interopDefaultLegacy(_toConsumableArray);
-var _set__default = /*#__PURE__*/_interopDefaultLegacy(_set);
-var _update__default = /*#__PURE__*/_interopDefaultLegacy(_update);
-var _isFunction__default = /*#__PURE__*/_interopDefaultLegacy(_isFunction);
-var _get__default = /*#__PURE__*/_interopDefaultLegacy(_get);
-var _isArray__default = /*#__PURE__*/_interopDefaultLegacy(_isArray);
-var _isString__default = /*#__PURE__*/_interopDefaultLegacy(_isString);
-var _objectDestructuringEmpty__default = /*#__PURE__*/_interopDefaultLegacy(_objectDestructuringEmpty);
-var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
-var _extends__default = /*#__PURE__*/_interopDefaultLegacy(_extends);
-var _objectWithoutProperties__default = /*#__PURE__*/_interopDefaultLegacy(_objectWithoutProperties);
-var _unset__default = /*#__PURE__*/_interopDefaultLegacy(_unset);
-var _uniqueId__default = /*#__PURE__*/_interopDefaultLegacy(_uniqueId);
-var _differenceBy__default = /*#__PURE__*/_interopDefaultLegacy(_differenceBy);
-var _findIndex__default = /*#__PURE__*/_interopDefaultLegacy(_findIndex);
-var _isFinite__default = /*#__PURE__*/_interopDefaultLegacy(_isFinite);
-var _max__default = /*#__PURE__*/_interopDefaultLegacy(_max);
-var _flatMap__default = /*#__PURE__*/_interopDefaultLegacy(_flatMap);
-var _without__default = /*#__PURE__*/_interopDefaultLegacy(_without);
-var _union__default = /*#__PURE__*/_interopDefaultLegacy(_union);
-var _flow__default = /*#__PURE__*/_interopDefaultLegacy(_flow);
-var ReactDOM__default = /*#__PURE__*/_interopDefaultLegacy(ReactDOM);
-var styled__default = /*#__PURE__*/_interopDefaultLegacy(styled);
-var _defineProperty__default = /*#__PURE__*/_interopDefaultLegacy(_defineProperty);
-var mitt__default = /*#__PURE__*/_interopDefaultLegacy(mitt);
-var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
-var _regeneratorRuntime__default = /*#__PURE__*/_interopDefaultLegacy(_regeneratorRuntime);
-var _asyncToGenerator__default = /*#__PURE__*/_interopDefaultLegacy(_asyncToGenerator);
-var _identity__default = /*#__PURE__*/_interopDefaultLegacy(_identity);
-
-var StartlibsContext = React__default['default'].createContext({});
-var PopupContext = React__default['default'].createContext({});
-var StartlibsMetacontext = React__default['default'].createContext(function () {});
+import _classCallCheck from '@babel/runtime/helpers/classCallCheck';
+import _createClass from '@babel/runtime/helpers/createClass';
+import _possibleConstructorReturn from '@babel/runtime/helpers/possibleConstructorReturn';
+import _getPrototypeOf from '@babel/runtime/helpers/getPrototypeOf';
+import _inherits from '@babel/runtime/helpers/inherits';
+import _debounce from 'lodash/fp/debounce';
+import React, { useCallback, useState, useRef, useEffect, useMemo, useContext, useLayoutEffect, useReducer, useInsertionEffect, startTransition, use } from 'react';
+import { callIfFunction, fixMediaQuery, ifUndefined, formatPath, _s, callIfFunctions, callMany } from '@startlibs/utils';
+import { clearPopups as clearPopups$1, SlotProvider as SlotProvider$1, willUseSharedCallback as willUseSharedCallback$1, useConsumerCatalog as useConsumerCatalog$1, useRefState as useRefState$1, useIsUnmounted as useIsUnmounted$1, useCatalogManager as useCatalogManager$1, willUseSharedState as willUseSharedState$1, useConstant as useConstant$1, useCallState as useCallState$1, useToggle as useToggle$1, willUseLayers as willUseLayers$1, useForceUpdate as useForceUpdate$1, useLazyConstant as useLazyConstant$1 } from '@startlibs/core';
+import _slicedToArray from '@babel/runtime/helpers/slicedToArray';
+import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
+import _set from 'lodash/fp/set';
+import _update from 'lodash/fp/update';
+import _isFunction from 'lodash/fp/isFunction';
+import _get from 'lodash/fp/get';
+import _isArray from 'lodash/fp/isArray';
+import _isString from 'lodash/fp/isString';
+import _objectDestructuringEmpty from '@babel/runtime/helpers/objectDestructuringEmpty';
+import _objectSpread from '@babel/runtime/helpers/objectSpread';
+import _extends from '@babel/runtime/helpers/extends';
+import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
+import _unset from 'lodash/fp/unset';
+import _uniqueId from 'lodash/fp/uniqueId';
+import _differenceBy from 'lodash/fp/differenceBy';
+import _findIndex from 'lodash/fp/findIndex';
+import _isFinite from 'lodash/fp/isFinite';
+import _max from 'lodash/fp/max';
+import _flatMap from 'lodash/fp/flatMap';
+import _without from 'lodash/fp/without';
+import _union from 'lodash/fp/union';
+import _flow from 'lodash/fp/flow';
+import ReactDOM from 'react-dom';
+import styled from 'styled-components';
+import _defineProperty from '@babel/runtime/helpers/defineProperty';
+import mitt from 'mitt';
+import _typeof from '@babel/runtime/helpers/typeof';
+import _regeneratorRuntime from '@babel/runtime/regenerator';
+import _asyncToGenerator from '@babel/runtime/helpers/asyncToGenerator';
+import _isPlainObject from 'lodash/fp/isPlainObject';
+import _identity from 'lodash/fp/identity';
+import 'lodash/array';
+
+var StartlibsContext = React.createContext({});
+var PopupContext = React.createContext({});
+var StartlibsMetacontext = React.createContext(function () {});
 var StartlibsConsumer = StartlibsContext.Consumer;
 var wrappeStyle = {
   height: '100%'
@@ -92,20 +50,20 @@ var wrappeStyle = {
 var StartlibsProvider =
 /*#__PURE__*/
 function (_React$Component) {
-  _inherits__default['default'](StartlibsProvider, _React$Component);
+  _inherits(StartlibsProvider, _React$Component);
 
   function StartlibsProvider() {
     var _getPrototypeOf2;
 
     var _this;
 
-    _classCallCheck__default['default'](this, StartlibsProvider);
+    _classCallCheck(this, StartlibsProvider);
 
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
 
-    _this = _possibleConstructorReturn__default['default'](this, (_getPrototypeOf2 = _getPrototypeOf__default['default'](StartlibsProvider)).call.apply(_getPrototypeOf2, [this].concat(args)));
+    _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(StartlibsProvider)).call.apply(_getPrototypeOf2, [this].concat(args)));
     _this.openToggles = new Map();
 
     _this.popupToggleRender = function (_ref, ref) {
@@ -120,7 +78,7 @@ function (_React$Component) {
     };
 
     _this.closePopup = function () {
-      core.clearPopups();
+      clearPopups$1();
     };
 
     _this.startlibsMeta = new Map();
@@ -130,7 +88,7 @@ function (_React$Component) {
 
       if (exists) return exists;
 
-      _this.startlibsMeta.set(key, utils.callIfFunction(initValue));
+      _this.startlibsMeta.set(key, callIfFunction(initValue));
 
       return initValue;
     };
@@ -138,10 +96,10 @@ function (_React$Component) {
     return _this;
   }
 
-  _createClass__default['default'](StartlibsProvider, [{
+  _createClass(StartlibsProvider, [{
     key: "componentDidMount",
     value: function componentDidMount() {
-      utils.fixMediaQuery();
+      fixMediaQuery();
 
       var addVHFix = function addVHFix() {
         var _document$documentEle, _document$documentEle2;
@@ -150,33 +108,33 @@ function (_React$Component) {
         (_document$documentEle = document.documentElement) === null || _document$documentEle === void 0 ? void 0 : (_document$documentEle2 = _document$documentEle.style) === null || _document$documentEle2 === void 0 ? void 0 : _document$documentEle2.setProperty('--vh', "".concat(vh, "px"));
       };
 
-      window.addEventListener('resize', _debounce__default['default'](200, addVHFix));
+      window.addEventListener('resize', _debounce(200, addVHFix));
       addVHFix();
     }
   }, {
     key: "render",
     value: function render() {
-      return React__default['default'].createElement(StartlibsContext.Provider, {
+      return React.createElement(StartlibsContext.Provider, {
         value: this.props.value
-      }, React__default['default'].createElement(StartlibsMetacontext.Provider, {
+      }, React.createElement(StartlibsMetacontext.Provider, {
         value: this.getMeta
-      }, React__default['default'].createElement(PopupContext.Provider, {
+      }, React.createElement(PopupContext.Provider, {
         value: this.popupToggleRender
-      }, React__default['default'].createElement("div", {
+      }, React.createElement("div", {
         style: wrappeStyle,
         onClick: this.closePopup
-      }, React__default['default'].createElement(core.SlotProvider, null, this.props.children)))));
+      }, React.createElement(SlotProvider$1, null, this.props.children)))));
     }
   }]);
 
   return StartlibsProvider;
-}(React__default['default'].Component);
+}(React.Component);
 
 var willUseLayers = function willUseLayers() {
-  var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React__default['default'].useEffect;
+  var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React.useEffect;
 
-  var _willUseSharedCallbac = core.willUseSharedCallback(useEffect),
-      _willUseSharedCallbac2 = _slicedToArray__default['default'](_willUseSharedCallbac, 3),
+  var _willUseSharedCallbac = willUseSharedCallback$1(useEffect),
+      _willUseSharedCallbac2 = _slicedToArray(_willUseSharedCallbac, 3),
       useRegisterSharedCallback = _willUseSharedCallbac2[0],
       callGroup = _willUseSharedCallbac2[1],
       _getSize = _willUseSharedCallbac2[2];
@@ -189,31 +147,31 @@ var willUseLayers = function willUseLayers() {
         onRemove = _ref.onRemove;
 
     var listener = arguments.length > 1 ? arguments[1] : undefined;
-    var resetIndex = React.useCallback(function () {
+    var resetIndex = useCallback(function () {
       setIndex(getIndex());
 
       if (getIndex() + 1 === _getSize()) {
-        utils.callIfFunction(onTop, getIndex);
+        callIfFunction(onTop, getIndex);
       }
     }, []);
     var getIndex = useRegisterSharedCallback(resetIndex, listener);
 
-    var _useState = React.useState(getIndex()),
-        _useState2 = _slicedToArray__default['default'](_useState, 2),
+    var _useState = useState(getIndex()),
+        _useState2 = _slicedToArray(_useState, 2),
         index = _useState2[0],
         setIndex = _useState2[1];
 
     useEffect(function () {
       if (getIndex() === 0) {
-        utils.callIfFunction(onFirst);
+        callIfFunction(onFirst);
       }
 
       resetIndex();
       return function () {
-        utils.callIfFunction(onRemove, _getSize());
+        callIfFunction(onRemove, _getSize());
 
         if (_getSize() === 0) {
-          utils.callIfFunction(onEmpty);
+          callIfFunction(onEmpty);
         }
 
         callGroup();
@@ -250,7 +208,7 @@ var callList = function callList(list, firstArg) {
 };
 
 var willUseSharedCallback = function willUseSharedCallback() {
-  var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React__default['default'].useEffect;
+  var useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React.useEffect;
   var mountedCallbacks = [];
   var listenerCallbacks = [];
 
@@ -305,7 +263,7 @@ var willUseSharedCallback = function willUseSharedCallback() {
 
   var useRegister = function useRegister(callback) {
     var listener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var ref = React.useRef(callback);
+    var ref = useRef(callback);
 
     if (ref.current !== callback) {
       ref.current = callback;
@@ -323,7 +281,7 @@ var willUseSharedCallback = function willUseSharedCallback() {
         add(ref);
 
         if (lastCallIndex !== lastCall.index && lastCall.current) {
-          callList.apply(void 0, [[ref]].concat(_toConsumableArray__default['default'](lastCall.current)));
+          callList.apply(void 0, [[ref]].concat(_toConsumableArray(lastCall.current)));
         }
       }
 
@@ -345,16 +303,16 @@ var willUseSharedCallback = function willUseSharedCallback() {
 
 var notDefined = {};
 var willUseSharedState = function willUseSharedState(initialValue) {
-  var _willUseSharedCallbac = core.willUseSharedCallback(),
-      _willUseSharedCallbac2 = _slicedToArray__default['default'](_willUseSharedCallbac, 3),
+  var _willUseSharedCallbac = willUseSharedCallback$1(),
+      _willUseSharedCallbac2 = _slicedToArray(_willUseSharedCallbac, 3),
       useRegisterGroupCallback = _willUseSharedCallbac2[0],
       callGroup = _willUseSharedCallbac2[1],
       getSize = _willUseSharedCallbac2[2];
 
-  var sharedValue = utils.ifUndefined(initialValue, notDefined);
+  var sharedValue = ifUndefined(initialValue, notDefined);
 
   var setGroupState = function setGroupState(newValue) {
-    sharedValue = utils.callIfFunction(newValue, sharedValue);
+    sharedValue = callIfFunction(newValue, sharedValue);
     callGroup(sharedValue);
   };
 
@@ -372,8 +330,8 @@ var willUseSharedState = function willUseSharedState(initialValue) {
       sharedValue = defaultValue;
     }
 
-    var _useState = React.useState(prevValue),
-        _useState2 = _slicedToArray__default['default'](_useState, 2),
+    var _useState = useState(prevValue),
+        _useState2 = _slicedToArray(_useState, 2),
         value = _useState2[0],
         setValue = _useState2[1];
 
@@ -393,7 +351,7 @@ var willUseSharedState = function willUseSharedState(initialValue) {
 var updateAllInputsState = function updateAllInputsState(inputs, values) {
   var deferedUndefined = [];
   inputs.forEach(function (input) {
-    var _input = _slicedToArray__default['default'](input, 2),
+    var _input = _slicedToArray(input, 2),
         setValue = _input[0],
         selector = _input[1];
 
@@ -406,7 +364,7 @@ var updateAllInputsState = function updateAllInputsState(inputs, values) {
     }
   });
   deferedUndefined.forEach(function (_ref) {
-    var _ref2 = _slicedToArray__default['default'](_ref, 2),
+    var _ref2 = _slicedToArray(_ref, 2),
         set = _ref2[0],
         value = _ref2[1];
 
@@ -415,14 +373,14 @@ var updateAllInputsState = function updateAllInputsState(inputs, values) {
 };
 
 var pathSelector = function pathSelector(path) {
-  return utils._s.get(path || []);
+  return _s.get(path || []);
 };
 
 var parsePathOrSelector = function parsePathOrSelector(pathOrSelector) {
   var isNotSelector = typeof pathOrSelector !== 'function';
 
   if (isNotSelector) {
-    return [utils.formatPath(pathOrSelector), pathSelector(pathOrSelector)];
+    return [formatPath(pathOrSelector), pathSelector(pathOrSelector)];
   } else {
     return ['', pathOrSelector];
   }
@@ -430,24 +388,24 @@ var parsePathOrSelector = function parsePathOrSelector(pathOrSelector) {
 
 var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var Context = React__default['default'].createContext(defaultContextValue);
+  var Context = React.createContext(defaultContextValue);
   var EMPTY_GLOBAL = {};
   var prevInitState = EMPTY_GLOBAL;
   var globalState = EMPTY_GLOBAL;
 
   var getGlobalState = function getGlobalState(key) {
-    return _isString__default['default'](key) || _isArray__default['default'](key) ? _get__default['default'](key, globalState) : globalState;
+    return _isString(key) || _isArray(key) ? _get(key, globalState) : globalState;
   };
 
   var useProvideSpreadState = function useProvideSpreadState(initState, setCallback) {
-    var _useConsumerCatalog = core.useConsumerCatalog(function (input) {
+    var _useConsumerCatalog = useConsumerCatalog$1(function (input) {
       return updateAllInputsState([input], state.get());
     }),
-        _useConsumerCatalog2 = _slicedToArray__default['default'](_useConsumerCatalog, 2),
+        _useConsumerCatalog2 = _slicedToArray(_useConsumerCatalog, 2),
         consumerList = _useConsumerCatalog2[0],
         manager = _useConsumerCatalog2[1];
 
-    var state = core.useRefState(initState, setCallback);
+    var state = useRefState$1(initState, setCallback);
 
     if (options.initRefCheck) {
       if (prevInitState !== initState) {
@@ -461,7 +419,7 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
       globalState = initState;
     }
 
-    React.useEffect(function () {
+    useEffect(function () {
       globalState = state.get();
     }, []);
 
@@ -472,33 +430,33 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
       updateAllInputsState(consumerList(), state.get());
     };
 
-    var contextValue = React.useMemo(function () {
+    var contextValue = useMemo(function () {
       return [state.get, setState, manager];
     }, []);
     return [Context.Provider, contextValue, [state.get, setState]];
   };
 
   var useSpreadState = function useSpreadState(pathOrSelector, inputs) {
-    var _useContext = React.useContext(Context),
-        _useContext2 = _slicedToArray__default['default'](_useContext, 3),
+    var _useContext = useContext(Context),
+        _useContext2 = _slicedToArray(_useContext, 3),
         getSpreadState = _useContext2[0],
         setSpreadState = _useContext2[1],
         manager = _useContext2[2];
 
     var _parsePathOrSelector = parsePathOrSelector(pathOrSelector),
-        _parsePathOrSelector2 = _slicedToArray__default['default'](_parsePathOrSelector, 2),
+        _parsePathOrSelector2 = _slicedToArray(_parsePathOrSelector, 2),
         path = _parsePathOrSelector2[0],
         selector = _parsePathOrSelector2[1];
 
     var pathOrInput = [path] || inputs || [];
 
-    var _useState = React.useState(selector(getSpreadState())),
-        _useState2 = _slicedToArray__default['default'](_useState, 2),
+    var _useState = useState(selector(getSpreadState())),
+        _useState2 = _slicedToArray(_useState, 2),
         value = _useState2[0],
         setValue = _useState2[1];
 
-    var isUnmounted = core.useIsUnmounted();
-    var currentPath = core.useRefState(path);
+    var isUnmounted = useIsUnmounted$1();
+    var currentPath = useRefState$1(path);
 
     if (path !== currentPath.get()) {
       /* when path changes, the consumerCatalogCallback will update the new value
@@ -511,7 +469,7 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
       currentPath.set(path);
     }
 
-    var input = React.useMemo(function () {
+    var input = useMemo(function () {
       return [function (v) {
         /* noop for elements that may be unregistered while looping through consumerList */
         if (path === currentPath.get() && !isUnmounted()) {
@@ -519,11 +477,11 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
         }
       }, selector];
     }, pathOrInput);
-    core.useCatalogManager(manager, input);
-    var setState = React.useCallback(function (v) {
-      return setSpreadState((_isFunction__default['default'](v) ? pathOrSelector === undefined ? function () {
+    useCatalogManager$1(manager, input);
+    var setState = useCallback(function (v) {
+      return setSpreadState((_isFunction(v) ? pathOrSelector === undefined ? function () {
         return v;
-      } : _update__default['default'] : _set__default['default'])(path, v), path);
+      } : _update : _set)(path, v), path);
     }, pathOrInput);
 
     var getValue = function getValue() {
@@ -536,44 +494,44 @@ var willUseSpreadState = function willUseSpreadState(defaultContextValue) {
   return [useProvideSpreadState, useSpreadState, Context, getGlobalState];
 };
 
-var SlotContext = React__default['default'].createContext(new Map());
+var SlotContext = React.createContext(new Map());
 
-var _willUseSharedState = core.willUseSharedState(),
-    _willUseSharedState2 = _slicedToArray__default['default'](_willUseSharedState, 2),
+var _willUseSharedState = willUseSharedState$1(),
+    _willUseSharedState2 = _slicedToArray(_willUseSharedState, 2),
     useFillHookState = _willUseSharedState2[0],
     useFillHookStateRef = _willUseSharedState2[1];
 
-var _willUseSharedState3 = core.willUseSharedState(),
-    _willUseSharedState4 = _slicedToArray__default['default'](_willUseSharedState3, 2),
+var _willUseSharedState3 = willUseSharedState$1(),
+    _willUseSharedState4 = _slicedToArray(_willUseSharedState3, 2),
     useHiddenFillHookState = _willUseSharedState4[0],
     useHiddenFillHookStateRef = _willUseSharedState4[1];
 
 var DEFAULT_CONTEXT = new Map();
 var SlotProvider = function SlotProvider(_ref) {
   var children = _ref.children;
-  return React__default['default'].createElement(SlotContext.Provider, {
+  return React.createElement(SlotContext.Provider, {
     value: DEFAULT_CONTEXT
-  }, children, React__default['default'].createElement(React__default['default'].Suspense, {
+  }, children, React.createElement(React.Suspense, {
     fallback: null
-  }, React__default['default'].createElement(FillHooks, null)), React__default['default'].createElement(HiddenFillHooks, null));
+  }, React.createElement(FillHooks, null)), React.createElement(HiddenFillHooks, null));
 };
 var Slot = function Slot(_ref2) {
   var name = _ref2.name,
       children = _ref2.children,
-      rest = _objectWithoutProperties__default['default'](_ref2, ["name", "children"]);
+      rest = _objectWithoutProperties(_ref2, ["name", "children"]);
 
-  var ref = React.useRef();
-  var slotInfo = core.useConstant({
+  var ref = useRef();
+  var slotInfo = useConstant$1({
     ref: ref
   });
-  var slots = React.useContext(SlotContext);
-  React.useLayoutEffect(function () {
+  var slots = useContext(SlotContext);
+  useLayoutEffect(function () {
     var previous = slots.get(name);
     var updates = (previous === null || previous === void 0 ? void 0 : previous.updates) || [];
 
     if (previous === null || previous === void 0 ? void 0 : previous.children) ;
 
-    slots.set(name, _flow__default['default'](_update__default['default']('infos', _union__default['default']([slotInfo])))(previous));
+    slots.set(name, _flow(_update('infos', _union([slotInfo])))(previous));
     updates.forEach(function (v) {
       return v({});
     });
@@ -581,29 +539,29 @@ var Slot = function Slot(_ref2) {
       var _previous$infos, _previous$updates;
 
       var previous = slots.get(name);
-      previous.infos = _without__default['default']([slotInfo], previous.infos);
+      previous.infos = _without([slotInfo], previous.infos);
 
       if (!((_previous$infos = previous.infos) === null || _previous$infos === void 0 ? void 0 : _previous$infos.length) && !((_previous$updates = previous.updates) === null || _previous$updates === void 0 ? void 0 : _previous$updates.length)) {
         slots.delete(name);
       }
     };
   }, [name]);
-  return children ? React__default['default'].createElement(React__default['default'].Fragment, null, React__default['default'].createElement("div", _extends__default['default']({
+  return children ? React.createElement(React.Fragment, null, React.createElement("div", _extends({
     "data-id": name
   }, rest, {
     ref: ref
-  })), React__default['default'].Children.map(children, function (c) {
-    return React__default['default'].cloneElement(c, _objectSpread__default['default']({}, c.props, {
+  })), React.Children.map(children, function (c) {
+    return React.cloneElement(c, _objectSpread({}, c.props, {
       name: name,
       stack: Number.MIN_SAFE_INTEGER
     }));
-  })) : React__default['default'].createElement("div", _extends__default['default']({
+  })) : React.createElement("div", _extends({
     "data-id": name
   }, rest, {
     ref: ref
   }));
 };
-var Invisible = styled__default['default'].div.withConfig({
+var Invisible = styled.div.withConfig({
   displayName: "SlotFill__Invisible",
   componentId: "h3oh7r-0"
 })(["display:none"]);
@@ -612,14 +570,14 @@ var FillBeforeFlip = function FillBeforeFlip(_ref3) {
   var name = _ref3.name,
       children = _ref3.children,
       slot = _ref3.slot;
-  var slots = React.useContext(SlotContext);
-  var ref = React.useRef();
-  React.useLayoutEffect(function () {
+  var slots = useContext(SlotContext);
+  var ref = useRef();
+  useLayoutEffect(function () {
     var _slots$get;
 
     var infos = ((_slots$get = slots.get(name)) === null || _slots$get === void 0 ? void 0 : _slots$get.infos) || [];
 
-    var mounted = _flatMap__default['default'](function (_ref4) {
+    var mounted = _flatMap(function (_ref4) {
       var ref = _ref4.ref;
       return ref === null || ref === void 0 ? void 0 : ref.current;
     }, infos);
@@ -642,23 +600,23 @@ var FillBeforeFlip = function FillBeforeFlip(_ref3) {
       });
     };
   }, []);
-  return React__default['default'].createElement(Invisible, {
+  return React.createElement(Invisible, {
     ref: ref
   }, children);
 };
 
 var useFillState = function useFillState(name, stack) {
-  var forceUpdate = React__default['default'].useState(false)[1];
-  var slots = React.useContext(SlotContext);
+  var forceUpdate = React.useState(false)[1];
+  var slots = useContext(SlotContext);
   var renderSlot = slots.get(name);
 
-  var maxStack = _max__default['default'](renderSlot === null || renderSlot === void 0 ? void 0 : renderSlot.stacks);
+  var maxStack = _max(renderSlot === null || renderSlot === void 0 ? void 0 : renderSlot.stacks);
 
-  var onStack = !_isFinite__default['default'](maxStack) || maxStack === stack;
-  React.useLayoutEffect(function () {
+  var onStack = !_isFinite(maxStack) || maxStack === stack;
+  useLayoutEffect(function () {
     var slot = slots.get(name);
 
-    var updatedSlot = _flow__default['default'](_update__default['default']('updates', _union__default['default']([forceUpdate])), _update__default['default']('stacks', _union__default['default']([stack])))(slot);
+    var updatedSlot = _flow(_update('updates', _union([forceUpdate])), _update('stacks', _union([stack])))(slot);
 
     slots.set(name, updatedSlot);
     updatedSlot.updates.forEach(function (v) {
@@ -668,7 +626,7 @@ var useFillState = function useFillState(name, stack) {
       var previous = slots.get(name);
       var index = previous.updates.indexOf(forceUpdate);
 
-      var next = _flow__default['default'](_update__default['default']('updates', utils._s.removeAt(index)), _update__default['default']('stacks', utils._s.removeAt(index)))(previous);
+      var next = _flow(_update('updates', _s.removeAt(index)), _update('stacks', _s.removeAt(index)))(previous);
 
       slots.set(name, next);
       next.updates.forEach(function (v) {
@@ -687,7 +645,7 @@ var Fill = function Fill(_ref5) {
       mountBeforeFlip = _ref5.mountBeforeFlip;
 
   var _useFillState = useFillState(name, stack),
-      _useFillState2 = _slicedToArray__default['default'](_useFillState, 2),
+      _useFillState2 = _slicedToArray(_useFillState, 2),
       slot = _useFillState2[0],
       onStack = _useFillState2[1];
 
@@ -695,10 +653,10 @@ var Fill = function Fill(_ref5) {
     return slot === null || slot === void 0 ? void 0 : slot.infos.map(function (info) {
       var _info$ref;
 
-      return ((_info$ref = info.ref) === null || _info$ref === void 0 ? void 0 : _info$ref.current) && ReactDOM__default['default'].createPortal(utils.callIfFunction(children, info), info.ref.current);
+      return ((_info$ref = info.ref) === null || _info$ref === void 0 ? void 0 : _info$ref.current) && ReactDOM.createPortal(callIfFunction(children, info), info.ref.current);
     });
   } else if (mountBeforeFlip) {
-    return React__default['default'].createElement(FillBeforeFlip, {
+    return React.createElement(FillBeforeFlip, {
       name: name,
       slot: slot
     }, children);
@@ -708,20 +666,20 @@ var Fill = function Fill(_ref5) {
 };
 
 var FillHooks = function FillHooks(_ref6) {
-  _objectDestructuringEmpty__default['default'](_ref6);
+  _objectDestructuringEmpty(_ref6);
 
   var _useFillHookState = useFillHookState({}),
-      _useFillHookState2 = _slicedToArray__default['default'](_useFillHookState, 1),
+      _useFillHookState2 = _slicedToArray(_useFillHookState, 1),
       hooked = _useFillHookState2[0];
 
   return Object.entries(hooked).map(function (_ref7) {
-    var _ref8 = _slicedToArray__default['default'](_ref7, 2),
+    var _ref8 = _slicedToArray(_ref7, 2),
         name = _ref8[0],
         childs = _ref8[1];
 
     return childs.map(function (_ref9, i) {
       var children = _ref9.children;
-      return React__default['default'].createElement(Fill, {
+      return React.createElement(Fill, {
         key: name + i,
         name: name
       }, children);
@@ -732,16 +690,16 @@ var FillHooks = function FillHooks(_ref6) {
 var uid = 0;
 var useFill = function useFill(name, children, inputs) {
   var _useFillHookStateRef = useFillHookStateRef(),
-      _useFillHookStateRef2 = _slicedToArray__default['default'](_useFillHookStateRef, 2),
+      _useFillHookStateRef2 = _slicedToArray(_useFillHookStateRef, 2),
       set = _useFillHookStateRef2[1];
 
-  var key = React.useRef(uid++);
-  React.useLayoutEffect(function () {
+  var key = useRef(uid++);
+  useLayoutEffect(function () {
     if (children) {
-      set(_update__default['default']([name], function () {
+      set(_update([name], function () {
         var list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
 
-        var index = _findIndex__default['default'](['key', key.current], list);
+        var index = _findIndex(['key', key.current], list);
 
         var value = {
           children: children,
@@ -749,21 +707,21 @@ var useFill = function useFill(name, children, inputs) {
         };
 
         if (index >= 0) {
-          return _set__default['default']([index], value, list);
+          return _set([index], value, list);
         } else {
           return list.concat(value);
         }
       }));
     } else {
-      set(_update__default['default']([name], _differenceBy__default['default']('key', _differenceBy__default['default'].placeholder, [{
+      set(_update([name], _differenceBy('key', _differenceBy.placeholder, [{
         children: children,
         key: key.current
       }])));
     }
   }, inputs || children);
-  React.useLayoutEffect(function () {
+  useLayoutEffect(function () {
     return function () {
-      return set(_update__default['default']([name], _differenceBy__default['default']('key', _differenceBy__default['default'].placeholder, [{
+      return set(_update([name], _differenceBy('key', _differenceBy.placeholder, [{
         key: key.current
       }])));
     };
@@ -771,53 +729,53 @@ var useFill = function useFill(name, children, inputs) {
 };
 
 var HiddenFillHooks = function HiddenFillHooks(_ref10) {
-  _objectDestructuringEmpty__default['default'](_ref10);
+  _objectDestructuringEmpty(_ref10);
 
   var _useHiddenFillHookSta = useHiddenFillHookState({}),
-      _useHiddenFillHookSta2 = _slicedToArray__default['default'](_useHiddenFillHookSta, 1),
+      _useHiddenFillHookSta2 = _slicedToArray(_useHiddenFillHookSta, 1),
       hookedChildren = _useHiddenFillHookSta2[0];
 
-  return React__default['default'].createElement("div", null, Object.values(hookedChildren));
+  return React.createElement("div", null, Object.values(hookedChildren));
 };
 
 var useHiddenFill = function useHiddenFill(children, inputs) {
   var _useHiddenFillHookSta3 = useHiddenFillHookStateRef(),
-      _useHiddenFillHookSta4 = _slicedToArray__default['default'](_useHiddenFillHookSta3, 2),
+      _useHiddenFillHookSta4 = _slicedToArray(_useHiddenFillHookSta3, 2),
       set = _useHiddenFillHookSta4[1];
 
-  var _useMemo = React.useMemo(function () {
-    return _uniqueId__default['default']("");
+  var _useMemo = useMemo(function () {
+    return _uniqueId("");
   }, []),
-      _useMemo2 = _slicedToArray__default['default'](_useMemo, 1),
+      _useMemo2 = _slicedToArray(_useMemo, 1),
       uid = _useMemo2[0];
 
-  set(_set__default['default']([uid], children ? React__default['default'].cloneElement(children, {
+  set(_set([uid], children ? React.cloneElement(children, {
     key: uid
   }) : null));
-  React.useEffect(function () {
+  useEffect(function () {
     return function () {
-      return set(_unset__default['default']([uid]));
+      return set(_unset([uid]));
     };
   }, []);
 };
 
 var propsOrConsume = function propsOrConsume(prop, Consumer, childrenAsFunction) {
-  return prop ? childrenAsFunction(prop) : React__default['default'].createElement(Consumer, null, childrenAsFunction);
+  return prop ? childrenAsFunction(prop) : React.createElement(Consumer, null, childrenAsFunction);
 };
 
 var addConsumers = function addConsumers(Component, obj) {
   return Object.entries(obj).reduce(function (acc, _ref) {
-    var _ref2 = _slicedToArray__default['default'](_ref, 2),
+    var _ref2 = _slicedToArray(_ref, 2),
         propKey = _ref2[0],
         Consumer = _ref2[1];
 
     return function (props) {
       return propsOrConsume(props[propKey], Consumer, function (v) {
-        return acc(_objectSpread__default['default'](_defineProperty__default['default']({}, propKey, v), props));
+        return acc(_objectSpread(_defineProperty({}, propKey, v), props));
       });
     };
   }, function (props) {
-    return React__default['default'].createElement(Component, props);
+    return React.createElement(Component, props);
   });
 };
 
@@ -831,8 +789,8 @@ var consumes = function consumes(obj) {
 };
 
 var withDialogError = function withDialogError(Dialog) {
-  var ErrorBoundedComponent = React__default['default'].forwardRef(function (props, ref) {
-    return React__default['default'].createElement(Dialog, _extends__default['default']({
+  var ErrorBoundedComponent = React.forwardRef(function (props, ref) {
+    return React.createElement(Dialog, _extends({
       ref: ref
     }, props)); // const ErrorBoundary = __internals('ErrorBoundary')
 
@@ -847,25 +805,25 @@ var withDialogError = function withDialogError(Dialog) {
 };
 
 var GroupEventFactory = function GroupEventFactory() {
-  var emitter = mitt__default['default']();
+  var emitter = mitt();
 
   var WithGroupEvent =
   /*#__PURE__*/
   function (_React$Component) {
-    _inherits__default['default'](WithGroupEvent, _React$Component);
+    _inherits(WithGroupEvent, _React$Component);
 
     function WithGroupEvent() {
       var _getPrototypeOf2;
 
       var _this;
 
-      _classCallCheck__default['default'](this, WithGroupEvent);
+      _classCallCheck(this, WithGroupEvent);
 
       for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
         args[_key] = arguments[_key];
       }
 
-      _this = _possibleConstructorReturn__default['default'](this, (_getPrototypeOf2 = _getPrototypeOf__default['default'](WithGroupEvent)).call.apply(_getPrototypeOf2, [this].concat(args)));
+      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(WithGroupEvent)).call.apply(_getPrototypeOf2, [this].concat(args)));
       _this.events = {};
 
       _this.processEvent = function (type, event) {
@@ -888,7 +846,7 @@ var GroupEventFactory = function GroupEventFactory() {
       return _this;
     }
 
-    _createClass__default['default'](WithGroupEvent, [{
+    _createClass(WithGroupEvent, [{
       key: "componentDidMount",
       value: function componentDidMount() {
         emitter.on('*', this.processEvent);
@@ -906,15 +864,15 @@ var GroupEventFactory = function GroupEventFactory() {
     }]);
 
     return WithGroupEvent;
-  }(React__default['default'].Component);
+  }(React.Component);
 
   return WithGroupEvent;
 };
 var withGroupEvent = function withGroupEvent(Component) {
   var WithGroupEvent = GroupEventFactory();
-  return React__default['default'].forwardRef(function (props, ref) {
-    return React__default['default'].createElement(WithGroupEvent, null, function (groupEvent) {
-      return React__default['default'].createElement(Component, _extends__default['default']({}, props, {
+  return React.forwardRef(function (props, ref) {
+    return React.createElement(WithGroupEvent, null, function (groupEvent) {
+      return React.createElement(Component, _extends({}, props, {
         ref: ref,
         groupEvent: groupEvent
       }));
@@ -925,39 +883,39 @@ var withGroupEvent = function withGroupEvent(Component) {
 var WithRef =
 /*#__PURE__*/
 function (_React$Component) {
-  _inherits__default['default'](WithRef, _React$Component);
+  _inherits(WithRef, _React$Component);
 
   function WithRef(props) {
     var _this;
 
-    _classCallCheck__default['default'](this, WithRef);
+    _classCallCheck(this, WithRef);
 
-    _this = _possibleConstructorReturn__default['default'](this, _getPrototypeOf__default['default'](WithRef).call(this, props));
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(WithRef).call(this, props));
     var total = props.length || props.children.length;
     var refs = new Array(total);
 
     for (var i = 0; i < total; i++) {
-      refs[i] = React__default['default'].createRef();
+      refs[i] = React.createRef();
     }
 
     _this.createdRefs = refs;
     return _this;
   }
 
-  _createClass__default['default'](WithRef, [{
+  _createClass(WithRef, [{
     key: "render",
     value: function render() {
       var children = this.props.children;
-      return children.apply(void 0, _toConsumableArray__default['default'](this.createdRefs));
+      return children.apply(void 0, _toConsumableArray(this.createdRefs));
     }
   }]);
 
   return WithRef;
-}(React__default['default'].Component);
+}(React.Component);
 
 var addExtraProp = function addExtraProp(element, extra) {
   var override = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-  return React__default['default'].cloneElement(element, override ? _objectSpread__default['default']({}, element.props, extra) : _objectSpread__default['default']({}, extra, element.props), element.props.children);
+  return React.cloneElement(element, override ? _objectSpread({}, element.props, extra) : _objectSpread({}, extra, element.props), element.props.children);
 };
 
 var WithLazyPlaceholder = function WithLazyPlaceholder(_ref) {
@@ -966,17 +924,17 @@ var WithLazyPlaceholder = function WithLazyPlaceholder(_ref) {
       children = _ref.children,
       _ref$forwardProps = _ref.forwardProps,
       forwardProps = _ref$forwardProps === void 0 ? false : _ref$forwardProps,
-      props = _objectWithoutProperties__default['default'](_ref, ["value", "fallback", "children", "forwardProps"]);
+      props = _objectWithoutProperties(_ref, ["value", "fallback", "children", "forwardProps"]);
 
-  return React__default['default'].createElement(React__default['default'].Suspense, {
-    fallback: React__default['default'].Children.map(children(fallback, {
+  return React.createElement(React.Suspense, {
+    fallback: React.Children.map(children(fallback, {
       isLoading: true
     }), function (child) {
-      return React__default['default'].isValidElement(child) ? addExtraProp(child, {
+      return React.isValidElement(child) ? addExtraProp(child, {
         isLoading: true
       }, false) : child;
     })
-  }, React__default['default'].createElement(Load, {
+  }, React.createElement(Load, {
     value: value,
     children: children,
     forwardProps: forwardProps && props
@@ -989,15 +947,15 @@ var WithLazyResource = function WithLazyResource(_ref2) {
       children = _ref2.children,
       _ref2$forwardProps = _ref2.forwardProps,
       forwardProps = _ref2$forwardProps === void 0 ? false : _ref2$forwardProps,
-      props = _objectWithoutProperties__default['default'](_ref2, ["value", "wrap", "fallback", "children", "forwardProps"]);
+      props = _objectWithoutProperties(_ref2, ["value", "wrap", "fallback", "children", "forwardProps"]);
 
-  return wrap || fallback !== undefined ? React__default['default'].createElement(React__default['default'].Suspense, {
-    fallback: utils.ifUndefined(fallback, null)
-  }, React__default['default'].createElement(Load, {
+  return wrap || fallback !== undefined ? React.createElement(React.Suspense, {
+    fallback: ifUndefined(fallback, null)
+  }, React.createElement(Load, {
     value: value,
     forwardProps: forwardProps && props,
     children: children
-  })) : React__default['default'].createElement(Load, {
+  })) : React.createElement(Load, {
     value: value,
     children: children,
     forwardProps: forwardProps && props
@@ -1008,20 +966,20 @@ var Load = function Load(_ref3) {
   var value = _ref3.value,
       children = _ref3.children,
       forwardProps = _ref3.forwardProps;
-  var loaded = _isArray__default['default'](value) ? value.forEach(function (v) {
+  var loaded = _isArray(value) ? value.forEach(function (v) {
     return v.promise();
   }) || value.map(function (v) {
     return v.read();
   }) : value.read();
 
-  var _useReducer = React.useReducer(function (s) {
+  var _useReducer = useReducer(function (s) {
     return s + 1;
   }, 0),
-      _useReducer2 = _slicedToArray__default['default'](_useReducer, 2),
+      _useReducer2 = _slicedToArray(_useReducer, 2),
       update = _useReducer2[1];
 
   var refresh = function refresh() {
-    return Promise.all(_isArray__default['default'](value) ? value.map(function (v) {
+    return Promise.all(_isArray(value) ? value.map(function (v) {
       return v.refresh().promise();
     }) : [value.refresh().promise()]).then(update);
   };
@@ -1036,13 +994,13 @@ var Load = function Load(_ref3) {
 };
 
 var useCallbackStable = function useCallbackStable(fn) {
-  var ref = React__default['default'].useRef([fn, function () {
+  var ref = React.useRef([fn, function () {
     return ref[0].apply(ref, arguments);
   }]).current; // Per Dan Abramov: useInsertionEffect executes marginally closer to the
   // correct timing for ref synchronization than useLayoutEffect on React 18.
   // See: https://github.com/facebook/react/pull/25881#issuecomment-1356244360
 
-  React.useInsertionEffect(function () {
+  useInsertionEffect(function () {
     ref[0] = fn;
   });
   return ref[1];
@@ -1052,7 +1010,7 @@ var WithEffect = function WithEffect(_ref) {
   var _ref$inputs = _ref.inputs,
       inputs = _ref$inputs === void 0 ? [] : _ref$inputs,
       children = _ref.children;
-  React.useEffect(children, inputs);
+  useEffect(children, inputs);
   return null;
 };
 
@@ -1063,10 +1021,10 @@ var useToggleInternal = function useToggleInternal() {
   var key = arguments.length > 3 ? arguments[3] : undefined;
   var isOpen = useStore(startWith);
   var closing = useStore(false);
-  var refIsOpen = core.useRefState(isOpen.get());
-  var refIsClosing = core.useRefState(closing.get());
-  var timerId = React.useRef();
-  var isUnmounted = core.useIsUnmounted();
+  var refIsOpen = useRefState$1(isOpen.get());
+  var refIsClosing = useRefState$1(closing.get());
+  var timerId = useRef();
+  var isUnmounted = useIsUnmounted$1();
 
   var clearClosing = function clearClosing() {
     if (refIsClosing.get() !== false) {
@@ -1078,11 +1036,11 @@ var useToggleInternal = function useToggleInternal() {
 
   var toggleWith = function toggleWith() {
     var value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-    var calledValue = utils.callIfFunction(value, refIsOpen.get());
+    var calledValue = callIfFunction(value, refIsOpen.get());
     var newValue = refIsOpen.get() === calledValue ? !calledValue : calledValue;
 
     if (!isUnmounted() && refIsOpen.get() !== newValue) {
-      var result = utils.callIfFunction(callback, newValue, refIsOpen.get());
+      var result = callIfFunction(callback, newValue, refIsOpen.get());
 
       if (result === false) {
         return;
@@ -1099,7 +1057,7 @@ var useToggleInternal = function useToggleInternal() {
       console.log(key, refIsOpen.get() !== value ? "toggle" : "clear", refIsOpen.get(), value);
     }
 
-    var nextValue = utils.callIfFunction(value, refIsOpen.get());
+    var nextValue = callIfFunction(value, refIsOpen.get());
 
     if (refIsOpen.get() !== nextValue) {
       toggleWith(function () {
@@ -1145,15 +1103,15 @@ var useToggleInternal = function useToggleInternal() {
     var end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
     return (
       /*#__PURE__*/
-      _asyncToGenerator__default['default'](
+      _asyncToGenerator(
       /*#__PURE__*/
-      _regeneratorRuntime__default['default'].mark(function _callee() {
+      _regeneratorRuntime.mark(function _callee() {
         var _len2,
             args,
             _key2,
             _args = arguments;
 
-        return _regeneratorRuntime__default['default'].wrap(function _callee$(_context) {
+        return _regeneratorRuntime.wrap(function _callee$(_context) {
           while (1) {
             switch (_context.prev = _context.next) {
               case 0:
@@ -1165,7 +1123,7 @@ var useToggleInternal = function useToggleInternal() {
                 }
 
                 _context.next = 5;
-                return utils.callIfFunction.apply(void 0, [promise].concat(args));
+                return callIfFunction.apply(void 0, [promise].concat(args));
 
               case 5:
                 return _context.abrupt("return", _context.sent);
@@ -1185,7 +1143,7 @@ var useToggleInternal = function useToggleInternal() {
     );
   };
 
-  var setters = React.useMemo(function () {
+  var setters = useMemo(function () {
     return {
       wait: function wait(promise) {
         var start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
@@ -1195,7 +1153,7 @@ var useToggleInternal = function useToggleInternal() {
       willWait: _wait,
       open: function open(e) {
         if (process.env.NODE_ENV !== 'production') {
-          if (['string', 'number', 'boolean'].indexOf(_typeof__default['default'](e)) >= 0) {
+          if (['string', 'number', 'boolean'].indexOf(_typeof(e)) >= 0) {
             console.log("You are trying to open toggle with ".concat(e, ". Please, use openWith to open with a value"));
           }
         }
@@ -1207,7 +1165,7 @@ var useToggleInternal = function useToggleInternal() {
       },
       toggle: function toggle(e) {
         if (process.env.NODE_ENV !== 'production') {
-          if (['string', 'number', 'boolean'].indexOf(_typeof__default['default'](e)) >= 0) {
+          if (['string', 'number', 'boolean'].indexOf(_typeof(e)) >= 0) {
             console.log("You are trying to toogle a toggle with ".concat(e, ". Please, use openWith to open with a value"));
           }
         }
@@ -1240,7 +1198,7 @@ var useToggleInternal = function useToggleInternal() {
     };
   }, []);
 
-  var settersWithNewRef = _objectSpread__default['default']({}, setters);
+  var settersWithNewRef = _objectSpread({}, setters);
 
   if (closing.val) {
     return Object.assign(settersWithNewRef, {
@@ -1263,10 +1221,10 @@ var useToggleInternal = function useToggleInternal() {
 };
 
 var useToggle = function useToggle(startWith, callback, key) {
-  return useToggleInternal(startWith, core.useCallState, callback, key);
+  return useToggleInternal(startWith, useCallState$1, callback, key);
 };
 var useRefToggle = function useRefToggle(startWith) {
-  return useToggleInternal(startWith, core.useRefState);
+  return useToggleInternal(startWith, useRefState$1);
 };
 
 var prevOpenToggleClose = function prevOpenToggleClose() {};
@@ -1280,8 +1238,8 @@ var clearPopups = function clearPopups() {
   }
 };
 var usePopupToggle = function usePopupToggle(startWith, callback) {
-  var toggle = core.useToggle(startWith, function (v, prev) {
-    var result = utils.callIfFunction(callback, v, prev);
+  var toggle = useToggle$1(startWith, function (v, prev) {
+    var result = callIfFunction(callback, v, prev);
 
     if (result === false) {
       return false;
@@ -1304,12 +1262,12 @@ var usePopupToggle = function usePopupToggle(startWith, callback) {
 };
 
 var useCallState = function useCallState(defaultValue, setCallback) {
-  var _useState = React.useState(defaultValue),
-      _useState2 = _slicedToArray__default['default'](_useState, 2),
+  var _useState = useState(defaultValue),
+      _useState2 = _slicedToArray(_useState, 2),
       val = _useState2[0],
       setValue = _useState2[1];
 
-  return React.useMemo(function () {
+  return useMemo(function () {
     var get = function get() {
       return val;
     };
@@ -1328,31 +1286,31 @@ var isPath = function isPath(path) {
 
 var getter = function getter(value) {
   return function (path) {
-    return path !== "" && isPath(path) ? utils._s.get(path, value) : value;
+    return path !== "" && isPath(path) ? _s.get(path, value) : value;
   };
 };
 
 var uninitialized = {};
 var useRefState = function useRefState(defaultValue, setCallback) {
-  var ref = React.useRef(uninitialized);
+  var ref = useRef(uninitialized);
 
   if (ref.current === uninitialized) {
-    ref.current = utils.callIfFunction(defaultValue);
+    ref.current = callIfFunction(defaultValue);
   }
 
-  return React.useMemo(function () {
+  return useMemo(function () {
     var get = function get(path) {
       return getter(ref.current)(path);
     };
 
     var set = function set(v, config) {
       var prev = ref.current;
-      ref.current = utils.callIfFunctions(v, function () {
+      ref.current = callIfFunctions(v, function () {
         return get();
       });
 
       if (prev !== ref.current && (!config || !config.ignoreCallback)) {
-        utils.callIfFunction(setCallback, prev, ref.current);
+        callIfFunction(setCallback, prev, ref.current);
       }
     };
 
@@ -1364,20 +1322,20 @@ var useRefState = function useRefState(defaultValue, setCallback) {
 };
 
 var useConsumerCatalog = function useConsumerCatalog(mountCallback, unmountCallback) {
-  var elements = core.useRefState([]);
-  var register = utils.callMany(function (element) {
+  var elements = useRefState$1([]);
+  var register = callMany(function (element) {
     return elements.set(function (elements) {
       return elements.concat([element]);
     });
   }, mountCallback);
-  var unregister = utils.callMany(function (element) {
+  var unregister = callMany(function (element) {
     return elements.set(function (elements) {
       return elements.filter(function (_) {
         return _ !== element;
       });
     });
   }, unmountCallback);
-  var manager = React.useMemo(function () {
+  var manager = useMemo(function () {
     return {
       register: register,
       unregister: unregister
@@ -1388,7 +1346,7 @@ var useConsumerCatalog = function useConsumerCatalog(mountCallback, unmountCallb
 var useCatalogManager = function useCatalogManager(_ref, ref) {
   var register = _ref.register,
       unregister = _ref.unregister;
-  React.useEffect(function () {
+  useEffect(function () {
     register(ref);
     return function () {
       return unregister(ref);
@@ -1396,8 +1354,8 @@ var useCatalogManager = function useCatalogManager(_ref, ref) {
   }, [ref]);
 };
 
-var _willUseLayers = core.willUseLayers(),
-    _willUseLayers2 = _slicedToArray__default['default'](_willUseLayers, 1),
+var _willUseLayers = willUseLayers$1(),
+    _willUseLayers2 = _slicedToArray(_willUseLayers, 1),
     useTitleLayers = _willUseLayers2[0];
 
 var useTitle = function useTitle(title) {
@@ -1408,7 +1366,7 @@ var useTitle = function useTitle(title) {
   });
 };
 
-var TabFocus = styled__default['default'].div.withConfig({
+var TabFocus = styled.div.withConfig({
   displayName: "useRecycleFocus__TabFocus",
   componentId: "kxnccs-0"
 })(["width:0;height:0;position:absolute;"]);
@@ -1436,25 +1394,25 @@ var useRecycleFocus = function useRecycleFocus(ref) {
     };
   };
 
-  return [React__default['default'].createElement(TabFocus, {
+  return [React.createElement(TabFocus, {
     tabIndex: 1,
     onFocus: recycle(0)
-  }), React__default['default'].createElement(TabFocus, {
+  }), React.createElement(TabFocus, {
     tabIndex: lastIndex || 1,
     onFocus: recycle(-1)
   })];
 };
 
 function usePrevious(value, initialValue) {
-  var ref = React.useRef(initialValue);
-  React.useEffect(function () {
+  var ref = useRef(initialValue);
+  useEffect(function () {
     ref.current = value;
   });
   return ref.current;
 }
 function usePreviousUnique(value, initialValue) {
-  var ref = React.useRef(initialValue);
-  React.useEffect(function () {
+  var ref = useRef(initialValue);
+  useEffect(function () {
     if (value !== ref.current) {
       ref.current = value;
     }
@@ -1462,8 +1420,8 @@ function usePreviousUnique(value, initialValue) {
   return ref.current;
 }
 function usePreviousForEffect(value, initialValue) {
-  var ref = React.useRef(initialValue);
-  React.useEffect(function () {
+  var ref = useRef(initialValue);
+  useEffect(function () {
     return function () {
       ref.current = value;
     };
@@ -1472,10 +1430,11 @@ function usePreviousForEffect(value, initialValue) {
 }
 
 var useIsUnmounted = function useIsUnmounted() {
-  var unmounted = React.useRef();
-  React.useEffect(function () {
+  var unmounted = useRef(false);
+  useEffect(function () {
+    unmounted.current = false;
     return function () {
-      return unmounted.current = true;
+      unmounted.current = true;
     };
   }, []);
   return function () {
@@ -1484,13 +1443,13 @@ var useIsUnmounted = function useIsUnmounted() {
 };
 
 var useEnsureRef = function useEnsureRef(forwardedRef) {
-  var ref = React.useRef();
+  var ref = useRef();
   return forwardedRef || ref;
 };
 
 var not_defined = {};
 var useConstant = function useConstant(value) {
-  var ref = React.useRef(not_defined);
+  var ref = useRef(not_defined);
 
   if (ref.current === not_defined) {
     ref.current = value;
@@ -1499,18 +1458,18 @@ var useConstant = function useConstant(value) {
   return ref.current;
 };
 var useLazyConstant = function useLazyConstant(value) {
-  var ref = React.useRef(not_defined);
+  var ref = useRef(not_defined);
 
   if (ref.current === not_defined) {
-    ref.current = utils.callIfFunction(value);
+    ref.current = callIfFunction(value);
   }
 
   return ref.current;
 };
 
 var useForceUpdate = function useForceUpdate() {
-  var _useState = React.useState(0),
-      _useState2 = _slicedToArray__default['default'](_useState, 2),
+  var _useState = useState(0),
+      _useState2 = _slicedToArray(_useState, 2),
       value = _useState2[0],
       setValue = _useState2[1]; // integer state
 
@@ -1522,14 +1481,14 @@ var useForceUpdate = function useForceUpdate() {
   }; // update the state to force render
 };
 var willUseForceUpdate = function willUseForceUpdate() {
-  var _willUseSharedState = core.willUseSharedState(),
-      _willUseSharedState2 = _slicedToArray__default['default'](_willUseSharedState, 3),
+  var _willUseSharedState = willUseSharedState$1(),
+      _willUseSharedState2 = _slicedToArray(_willUseSharedState, 3),
       useValue = _willUseSharedState2[0],
       set = _willUseSharedState2[2];
 
   var useForceUpdate = function useForceUpdate() {
     var _useValue = useValue(0),
-        _useValue2 = _slicedToArray__default['default'](_useValue, 2),
+        _useValue2 = _slicedToArray(_useValue, 2),
         v = _useValue2[0],
         setV = _useValue2[1];
 
@@ -1549,9 +1508,9 @@ var willUseForceUpdate = function willUseForceUpdate() {
 
 var useUpdateOnResize = function useUpdateOnResize() {
   var debounceInterval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 200;
-  var update = core.useForceUpdate();
-  React.useEffect(function () {
-    var trigger = _debounce__default['default'](debounceInterval, update);
+  var update = useForceUpdate$1();
+  useEffect(function () {
+    var trigger = _debounce(debounceInterval, update);
 
     window.addEventListener('resize', trigger);
     return function () {
@@ -1561,19 +1520,19 @@ var useUpdateOnResize = function useUpdateOnResize() {
 };
 
 var useAsyncEffect = function useAsyncEffect(fn, args) {
-  React.useEffect(function () {
+  useEffect(function () {
     var result = fn();
     return function () {
       result.then(function (end) {
-        return utils.callIfFunction(end);
+        return callIfFunction(end);
       });
     };
   }, args);
 };
 
 var useUpdateEffect = function useUpdateEffect(effect, inputs) {
-  var pastFirstTime = React.useRef();
-  React.useEffect(function () {
+  var pastFirstTime = useRef();
+  useEffect(function () {
     if (pastFirstTime.current) {
       return effect();
     } else {
@@ -1583,19 +1542,19 @@ var useUpdateEffect = function useUpdateEffect(effect, inputs) {
 };
 
 var useRefMemo = function useRefMemo(value) {
-  var ref = React.useRef(value);
+  var ref = useRef(value);
 
   if (ref.current !== value) {
-    ref.current = utils.callIfFunction(value);
+    ref.current = callIfFunction(value);
   }
 
   return ref;
 };
 
 var IS_ARRAY_ITEMS_EQUALS = function IS_ARRAY_ITEMS_EQUALS(a, b) {
-  return a.length === b.length && a.findIndex(function (itemA, i) {
-    return !Object.is(itemA, b[i]);
-  }) < 0;
+  return a.length === b.length && !a.some(function (x, i) {
+    return !Object.is(x, b[i]);
+  });
 };
 
 var IS_DEPS_EQUALS = function IS_DEPS_EQUALS() {
@@ -1605,32 +1564,41 @@ var IS_DEPS_EQUALS = function IS_DEPS_EQUALS() {
 };
 
 var SHALLOW_IS_EQUAL = function SHALLOW_IS_EQUAL(a, b) {
-  return Object.is(a, b) || _isArray__default['default'](a) && _isArray__default['default'](b) && IS_ARRAY_ITEMS_EQUALS(a, b);
+  return Object.is(a, b) || _isArray(a) && _isArray(b) && IS_ARRAY_ITEMS_EQUALS(a, b);
 };
 
 var EMPTY_DEPS = [];
+var EMPTY_VALUE = {
+  "EMPTY": true
+};
 var useUpdateSignal = function useUpdateSignal(initialValue) {
-  var value = React.useRef(initialValue);
+  var value = useRef(initialValue);
   value.current = initialValue;
-  return core.useLazyConstant(function () {
+  return useLazyConstant$1(function () {
     var registered = [];
 
     var register = function register() {
-      var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity__default['default'];
+      var selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity;
       var isEqual = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : SHALLOW_IS_EQUAL;
-      var selectorRef = React.useRef();
+      var withTransition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      var selectorRef = useRef();
       selectorRef.current = selector;
-      var update = core.useForceUpdate();
-      var lastValueRef = React.useRef(utils._s.select(selectorRef.current, value.current));
-      React.useEffect(function () {
-        var item = [update, selectorRef, isEqual, lastValueRef];
-        registered = _toConsumableArray__default['default'](registered).concat([item]);
+      var update = useForceUpdate$1();
+      var lastValueRef = useRef(_s.select(selectorRef.current, value.current));
+      useEffect(function () {
+        var item = [update, selectorRef, isEqual, lastValueRef, withTransition];
+        registered = _toConsumableArray(registered).concat([item]);
         return function () {
           registered = registered.filter(function (v) {
             return v !== item;
           });
         };
       }, []);
+
+      if (value.current === EMPTY_VALUE) {
+        return EMPTY_VALUE;
+      }
+
       return lastValueRef.current;
     };
 
@@ -1640,17 +1608,25 @@ var useUpdateSignal = function useUpdateSignal(initialValue) {
       }
 
       return registered.forEach(function (_ref) {
-        var _ref2 = _slicedToArray__default['default'](_ref, 4),
+        var _ref2 = _slicedToArray(_ref, 5),
             fn = _ref2[0],
             selectorRef = _ref2[1],
             isEqual = _ref2[2],
-            lastValueRef = _ref2[3];
+            lastValueRef = _ref2[3],
+            withTransition = _ref2[4];
 
-        var nextValue = utils._s.select.apply(utils._s, [selectorRef.current].concat(args));
+        var nextValue = _s.select.apply(_s, [selectorRef.current].concat(args));
 
-        if (!utils.callIfFunction(isEqual, nextValue, lastValueRef.current)) {
+        if (!callIfFunction(isEqual, nextValue, lastValueRef.current)) {
           lastValueRef.current = nextValue;
-          fn(nextValue);
+
+          if (withTransition) {
+            (withTransition === true ? startTransition : withTransition)(function () {
+              return fn(nextValue);
+            });
+          } else {
+            fn(nextValue);
+          }
         }
       });
     };
@@ -1658,38 +1634,44 @@ var useUpdateSignal = function useUpdateSignal(initialValue) {
     return [register, call];
   });
 };
-var useSelectorSignal = function useSelectorSignal(value) {
-  var prevValue = React.useRef(value);
-  var prevDeps = React.useRef(EMPTY_DEPS);
 
-  var _useState = React.useState(prevDeps.current),
-      _useState2 = _slicedToArray__default['default'](_useState, 2),
-      currentDeps = _useState2[0],
-      setCurrentDeps = _useState2[1];
+var useSelectorSignal = function useSelectorSignal(value) {
+  var prevValue = useRef(value);
 
   var _useUpdateSignal = useUpdateSignal(value),
-      _useUpdateSignal2 = _slicedToArray__default['default'](_useUpdateSignal, 2),
+      _useUpdateSignal2 = _slicedToArray(_useUpdateSignal, 2),
       _register = _useUpdateSignal2[0],
       call = _useUpdateSignal2[1];
 
-  var register = React.useCallback(function (selector, deps, isEqual) {
-    if (!IS_DEPS_EQUALS(deps, prevDeps.current)) {
-      setCurrentDeps(deps);
+  var register = useCallback(function (selector, deps, isEqual, withTransition) {
+    var prevDeps = useRef(EMPTY_DEPS);
+
+    if (prevDeps.current !== EMPTY_DEPS && !IS_DEPS_EQUALS(deps, prevDeps.current)) {
+      call(prevValue.current);
     }
 
-    return _register(selector, isEqual);
+    prevDeps.current = deps;
+    return _register(selector, isEqual, withTransition);
   }, []);
-  React.useEffect(function () {
-    if (prevValue.current !== value || currentDeps !== prevDeps.current) {
+  useEffect(function () {
+    if (prevValue.current !== value) {
       prevValue.current = value;
-      prevDeps.current = currentDeps;
       call(value);
     }
-  }, [value, currentDeps]);
+  }, [value]);
   return register;
 };
-var createStatefulContext = function createStatefulContext(v) {
-  var Ctx = React__default['default'].createContext(v);
+
+var updateStateFn = function updateStateFn(path, update) {
+  return function (state) {
+    return path ? _update(path, function (v) {
+      return callIfFunction(update, v);
+    }, state) : callIfFunction(update, state);
+  };
+};
+
+var createStatefulContext = function createStatefulContext(v, defaultIsEqual) {
+  var Ctx = React.createContext(v);
 
   var Provider = function Provider(_ref3) {
     var value = _ref3.value,
@@ -1697,146 +1679,215 @@ var createStatefulContext = function createStatefulContext(v) {
         utils = _ref3.utils,
         children = _ref3.children;
     var register = useSelectorSignal(value);
-    var v = core.useLazyConstant(function () {
+    var v = useLazyConstant$1(function () {
       return [register, setValue, utils];
     });
-    return React__default['default'].createElement(Ctx.Provider, {
+    return React.createElement(Ctx.Provider, {
       value: v
     }, children);
   };
 
-  var useSelectValue = function useSelectValue(selector, deps, isEqual) {
-    var _useContext = React.useContext(Ctx),
-        _useContext2 = _slicedToArray__default['default'](_useContext, 1),
-        useRegister = _useContext2[0];
+  var useCtx = function useCtx() {
+    return useContext(Ctx);
+  };
+
+  var useSelectValue = function useSelectValue(selector, deps, defaultIsEqual, withTransition) {
+    var _useCtx = useCtx(),
+        _useCtx2 = _slicedToArray(_useCtx, 1),
+        useRegister = _useCtx2[0];
 
-    return useRegister(selector, deps, isEqual);
+    if (deps === true) {
+      return useRegister(selector, [], undefined, startTransition);
+    } else if (_isPlainObject(deps)) {
+      return useRegister(selector, deps.deps, deps.isEqual, deps.withTransition);
+    } else {
+      return useRegister(selector, _isArray(deps) ? deps : deps === null || deps === void 0 ? void 0 : deps.deps, isEqual, withTransition);
+    }
   };
 
-  var useSetValue = function useSetValue(path, deps) {
-    var _useContext3 = React.useContext(Ctx),
-        _useContext4 = _slicedToArray__default['default'](_useContext3, 2),
-        reg = _useContext4[0],
-        set = _useContext4[1];
-
-    return core.useConstant(function (update) {
-      return set(function (state) {
-        return path ? _update__default['default'](path, function (v) {
-          return utils.callIfFunction(update, v);
-        }, state) : utils.callIfFunction(update, state);
-      });
+  var useSetValue = function useSetValue(path) {
+    var _useCtx3 = useCtx(),
+        _useCtx4 = _slicedToArray(_useCtx3, 2),
+        reg = _useCtx4[0],
+        set = _useCtx4[1];
+
+    return useConstant$1(function (update) {
+      return set(updateStateFn(path, update));
     });
   };
 
   var useUtils = function useUtils(path, deps) {
-    var _useContext5 = React.useContext(Ctx),
-        _useContext6 = _slicedToArray__default['default'](_useContext5, 3),
-        reg = _useContext6[0],
-        set = _useContext6[1],
-        utils = _useContext6[2];
+    var _useCtx5 = useCtx(),
+        _useCtx6 = _slicedToArray(_useCtx5, 3),
+        reg = _useCtx6[0],
+        set = _useCtx6[1],
+        utils = _useCtx6[2];
 
     return utils;
   };
 
-  return [Provider, [useSelectValue, useSetValue, useUtils]];
+  return [Provider, [useSelectValue, useSetValue, useUtils, useCtx]];
 };
-var createSelfStatefulContext = function createSelfStatefulContext(v) {
-  var Ctx = React__default['default'].createContext(v);
+var createSelfStatefulContext = function createSelfStatefulContext(v, defaultIsEqual) {
+  var _createStatefulContex = createStatefulContext(v),
+      _createStatefulContex2 = _slicedToArray(_createStatefulContex, 2),
+      Provider = _createStatefulContex2[0],
+      _createStatefulContex3 = _slicedToArray(_createStatefulContex2[1], 4),
+      useSelectValue = _createStatefulContex3[0],
+      useSetValue = _createStatefulContex3[1],
+      useUtils = _createStatefulContex3[2],
+      useCtx = _createStatefulContex3[3];
 
-  var Provider = function Provider(_ref4) {
+  var StateFullProvider = function StateFullProvider(_ref4) {
     var _ref4$init = _ref4.init,
         init = _ref4$init === void 0 ? {} : _ref4$init,
         utils = _ref4.utils,
         children = _ref4.children;
 
-    var _useState3 = React.useState(init),
-        _useState4 = _slicedToArray__default['default'](_useState3, 2),
-        value = _useState4[0],
-        setValue = _useState4[1];
+    var _useState = useState(init),
+        _useState2 = _slicedToArray(_useState, 2),
+        state = _useState2[0],
+        setState = _useState2[1];
 
-    var register = useSelectorSignal(value);
-    var v = core.useLazyConstant(function () {
-      return [register, setValue, utils];
-    });
-    return React__default['default'].createElement(Ctx.Provider, {
-      value: v
+    return React.createElement(Provider, {
+      value: state,
+      setValue: setState,
+      utils: utils
     }, children);
   };
 
-  var useSelectValue = function useSelectValue(selector, deps, isEqual) {
-    var _useContext7 = React.useContext(Ctx),
-        _useContext8 = _slicedToArray__default['default'](_useContext7, 1),
-        useRegister = _useContext8[0];
+  return [StateFullProvider, [useSelectValue, useSetValue, useUtils, useCtx]];
+};
+var createLazyStatefulContext = function createLazyStatefulContext(toPromise, defaultIsEqual) {
+  var _createStatefulContex4 = createStatefulContext(EMPTY_VALUE),
+      _createStatefulContex5 = _slicedToArray(_createStatefulContex4, 2),
+      Provider = _createStatefulContex5[0],
+      _createStatefulContex6 = _slicedToArray(_createStatefulContex5[1], 4),
+      useSelectValue = _createStatefulContex6[0],
+      useSetValue = _createStatefulContex6[1],
+      useUtils = _createStatefulContex6[2],
+      useCtx = _createStatefulContex6[3];
+
+  var useSelectLazyValue = function useSelectLazyValue(selector, deps) {
+    var isEqual = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultIsEqual;
+    var value = useSelectValue(selector, deps, isEqual);
+    var utils = useUtils();
+
+    if (value === EMPTY_VALUE) {
+      var loadedValue = use(utils._lazyValue());
+      return _s.select(selector, loadedValue);
+    }
 
-    return useRegister(selector, deps, isEqual);
+    return value;
   };
 
-  var useSetState = function useSetState(path, deps) {
-    var _useContext9 = React.useContext(Ctx),
-        _useContext10 = _slicedToArray__default['default'](_useContext9, 3),
-        useRegister = _useContext10[0],
-        set = _useContext10[1],
-        utils$1 = _useContext10[2];
-
-    var setValue = core.useConstant(function (update) {
-      return set(function (state) {
-        return path ? _update__default['default'](path, function (v) {
-          return utils.callIfFunction(update, v);
-        }, state) : utils.callIfFunction(update, state);
+  var useSetLazyValue = function useSetLazyValue(path) {
+    var _useCtx7 = useCtx(),
+        _useCtx8 = _slicedToArray(_useCtx7, 3),
+        setValue = _useCtx8[1],
+        utils = _useCtx8[2];
+
+    return useConstant$1(function (update) {
+      return setValue(function (value) {
+        return value === EMPTY_VALUE ? updateStateFn(path, update)(utils.loadedValue()) : updateStateFn(path, update)(value);
       });
     });
-    return setValue;
   };
 
-  var useUtils = function useUtils(path, deps) {
-    var _useContext11 = React.useContext(Ctx),
-        _useContext12 = _slicedToArray__default['default'](_useContext11, 3),
-        useRegister = _useContext12[0],
-        set = _useContext12[1],
-        utils = _useContext12[2];
+  var useValuePromise = function useValuePromise(selector, deps, isEqual) {
+    var value = useSelectValue(selector, deps, isEqual);
+    var utils = useUtils();
+    return useCallback(function () {
+      if (value === EMPTY_VALUE) {
+        return utils._lazyValue().then(function (v) {
+          return console.log(v, _s.select(selector, v), selector) || _s.select(selector, v);
+        });
+      }
 
-    return utils;
+      return new Promise(value);
+    }, [value, deps]);
   };
 
-  return [Provider, [useSelectValue, useSetState, useUtils]];
+  var LazyStateFullProvider = function LazyStateFullProvider(_ref5) {
+    var value = _ref5.value,
+        utils = _ref5.utils,
+        children = _ref5.children,
+        _ref5$fallback = _ref5.fallback,
+        fallback = _ref5$fallback === void 0 ? null : _ref5$fallback;
+
+    var _useState3 = useState(EMPTY_VALUE),
+        _useState4 = _slicedToArray(_useState3, 2),
+        state = _useState4[0],
+        setState = _useState4[1];
+
+    var promise = useRef();
+
+    var _loadedValue = useRef();
+
+    var lazyUtils = useMemo(function () {
+      return _objectSpread({}, utils, {
+        _lazyValue: function _lazyValue() {
+          var _promise$current;
+
+          (_promise$current = promise.current) !== null && _promise$current !== void 0 ? _promise$current : promise.current = callIfFunction(toPromise || _identity, value);
+          promise.current.then(function (value) {
+            _loadedValue.current = value;
+          });
+          return promise.current;
+        },
+        loadedValue: function loadedValue() {
+          return _loadedValue.current;
+        }
+      });
+    }, [value, utils]);
+    return React.createElement(Provider, {
+      value: state,
+      setValue: setState,
+      utils: lazyUtils
+    }, fallback === false ? children : React.createElement(React.Suspense, {
+      fallback: fallback
+    }, children));
+  };
+
+  return [LazyStateFullProvider, [useSelectLazyValue, useSetLazyValue, useValuePromise]];
 };
 var createSelectableContext = function createSelectableContext(v) {
-  var _createStatefulContex = createStatefulContext(v),
-      _createStatefulContex2 = _slicedToArray__default['default'](_createStatefulContex, 2),
-      Provider = _createStatefulContex2[0],
-      _createStatefulContex3 = _slicedToArray__default['default'](_createStatefulContex2[1], 1),
-      useSelectValue = _createStatefulContex3[0];
+  var _createStatefulContex7 = createStatefulContext(v),
+      _createStatefulContex8 = _slicedToArray(_createStatefulContex7, 2),
+      Provider = _createStatefulContex8[0],
+      _createStatefulContex9 = _slicedToArray(_createStatefulContex8[1], 1),
+      useSelectValue = _createStatefulContex9[0];
 
   return [Provider, useSelectValue];
 };
 var createTriggerUpdateContext = function createTriggerUpdateContext(v) {
-  var _createStatefulContex4 = createStatefulContext(v),
-      _createStatefulContex5 = _slicedToArray__default['default'](_createStatefulContex4, 2),
-      Provider = _createStatefulContex5[0],
-      _createStatefulContex6 = _slicedToArray__default['default'](_createStatefulContex5[1], 1),
-      useSelectValue = _createStatefulContex6[0];
+  var _createStatefulContex10 = createStatefulContext(v),
+      _createStatefulContex11 = _slicedToArray(_createStatefulContex10, 2),
+      Provider = _createStatefulContex11[0],
+      _createStatefulContex12 = _slicedToArray(_createStatefulContex11[1], 1),
+      useSelectValue = _createStatefulContex12[0];
 
-  var TriggerProvider = React__default['default'].forwardRef(function (_ref5, ref) {
-    var children = _ref5.children;
+  var TriggerProvider = React.forwardRef(function (_ref6, ref) {
+    var children = _ref6.children;
 
-    var _useState5 = React.useState(0),
-        _useState6 = _slicedToArray__default['default'](_useState5, 2),
+    var _useState5 = useState(0),
+        _useState6 = _slicedToArray(_useState5, 2),
         v = _useState6[0],
         setV = _useState6[1];
 
-    var trigger = React__default['default'].useMemo(function () {
+    var trigger = React.useMemo(function () {
       return function () {
         return setV(function (v) {
           return v + 1;
         });
       };
     }, [v]);
-    React__default['default'].useImperativeHandle(ref, function () {
+    React.useImperativeHandle(ref, function () {
       return {
         trigger: trigger
       };
     }, []);
-    return React__default['default'].createElement(Provider, {
+    return React.createElement(Provider, {
       value: trigger
     }, children);
   });
@@ -1848,61 +1899,8 @@ var WithConstant = function WithConstant(_ref) {
       inputs = _ref$inputs === void 0 ? [] : _ref$inputs,
       value = _ref.value,
       children = _ref.children;
-  var constant = core.useLazyConstant(value, inputs);
+  var constant = useLazyConstant$1(value, inputs);
   return children(constant);
 };
 
-exports.Fill = Fill;
-exports.GroupEventFactory = GroupEventFactory;
-exports.PopupContext = PopupContext;
-exports.Slot = Slot;
-exports.SlotContext = SlotContext;
-exports.SlotProvider = SlotProvider;
-exports.StartlibsConsumer = StartlibsConsumer;
-exports.StartlibsContext = StartlibsContext;
-exports.StartlibsMetacontext = StartlibsMetacontext;
-exports.StartlibsProvider = StartlibsProvider;
-exports.WithConstant = WithConstant;
-exports.WithEffect = WithEffect;
-exports.WithLazyPlaceholder = WithLazyPlaceholder;
-exports.WithLazyResource = WithLazyResource;
-exports.WithRef = WithRef;
-exports.clearPopups = clearPopups;
-exports.consumes = consumes;
-exports.createSelectableContext = createSelectableContext;
-exports.createSelfStatefulContext = createSelfStatefulContext;
-exports.createStatefulContext = createStatefulContext;
-exports.createTriggerUpdateContext = createTriggerUpdateContext;
-exports.useAsyncEffect = useAsyncEffect;
-exports.useCallState = useCallState;
-exports.useCallbackStable = useCallbackStable;
-exports.useCatalogManager = useCatalogManager;
-exports.useConstant = useConstant;
-exports.useConsumerCatalog = useConsumerCatalog;
-exports.useEnsureRef = useEnsureRef;
-exports.useFill = useFill;
-exports.useForceUpdate = useForceUpdate;
-exports.useHiddenFill = useHiddenFill;
-exports.useIsUnmounted = useIsUnmounted;
-exports.useLazyConstant = useLazyConstant;
-exports.usePopupToggle = usePopupToggle;
-exports.usePrevious = usePrevious;
-exports.usePreviousForEffect = usePreviousForEffect;
-exports.usePreviousUnique = usePreviousUnique;
-exports.useRecycleFocus = useRecycleFocus;
-exports.useRefMemo = useRefMemo;
-exports.useRefState = useRefState;
-exports.useRefToggle = useRefToggle;
-exports.useSelectorSignal = useSelectorSignal;
-exports.useTitle = useTitle;
-exports.useToggle = useToggle;
-exports.useUpdateEffect = useUpdateEffect;
-exports.useUpdateOnResize = useUpdateOnResize;
-exports.useUpdateSignal = useUpdateSignal;
-exports.willUseForceUpdate = willUseForceUpdate;
-exports.willUseLayers = willUseLayers;
-exports.willUseSharedCallback = willUseSharedCallback;
-exports.willUseSharedState = willUseSharedState;
-exports.willUseSpreadState = willUseSpreadState;
-exports.withDialogError = withDialogError;
-exports.withGroupEvent = withGroupEvent;
+export { Fill, GroupEventFactory, PopupContext, Slot, SlotContext, SlotProvider, StartlibsConsumer, StartlibsContext, StartlibsMetacontext, StartlibsProvider, WithConstant, WithEffect, WithLazyPlaceholder, WithLazyResource, WithRef, clearPopups, consumes, createLazyStatefulContext, createSelectableContext, createSelfStatefulContext, createStatefulContext, createTriggerUpdateContext, useAsyncEffect, useCallState, useCallbackStable, useCatalogManager, useConstant, useConsumerCatalog, useEnsureRef, useFill, useForceUpdate, useHiddenFill, useIsUnmounted, useLazyConstant, usePopupToggle, usePrevious, usePreviousForEffect, usePreviousUnique, useRecycleFocus, useRefMemo, useRefState, useRefToggle, useTitle, useToggle, useUpdateEffect, useUpdateOnResize, useUpdateSignal, willUseForceUpdate, willUseLayers, willUseSharedCallback, willUseSharedState, willUseSpreadState, withDialogError, withGroupEvent };