@startlibs/core 1.0.7 → 1.1.0

package/lib/index.cjs

@@ -0,0 +1,1474 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _debounce = require('lodash/fp/debounce');
+var React = require('react');
+var utils = require('@startlibs/utils');
+var _objectDestructuringEmpty = require('@babel/runtime/helpers/objectDestructuringEmpty');
+var _defineProperty = require('@babel/runtime/helpers/defineProperty');
+var _extends = require('@babel/runtime/helpers/extends');
+var _objectWithoutProperties = require('@babel/runtime/helpers/objectWithoutProperties');
+var _slicedToArray = require('@babel/runtime/helpers/slicedToArray');
+var _unset = require('lodash/fp/unset');
+var _uniqueId = require('lodash/fp/uniqueId');
+var _differenceBy = require('lodash/fp/differenceBy');
+var _set = require('lodash/fp/set');
+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 _update = require('lodash/fp/update');
+var _flow = require('lodash/fp/flow');
+var ReactDOM = require('react-dom');
+var styled = require('styled-components');
+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 mitt = require('mitt');
+var _isPlainObject = require('lodash/fp/isPlainObject');
+var _identity = require('lodash/fp/identity');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { 'default': e }; }
+
+var _debounce__default = /*#__PURE__*/_interopDefault(_debounce);
+var React__default = /*#__PURE__*/_interopDefault(React);
+var _objectDestructuringEmpty__default = /*#__PURE__*/_interopDefault(_objectDestructuringEmpty);
+var _defineProperty__default = /*#__PURE__*/_interopDefault(_defineProperty);
+var _extends__default = /*#__PURE__*/_interopDefault(_extends);
+var _objectWithoutProperties__default = /*#__PURE__*/_interopDefault(_objectWithoutProperties);
+var _slicedToArray__default = /*#__PURE__*/_interopDefault(_slicedToArray);
+var _unset__default = /*#__PURE__*/_interopDefault(_unset);
+var _uniqueId__default = /*#__PURE__*/_interopDefault(_uniqueId);
+var _differenceBy__default = /*#__PURE__*/_interopDefault(_differenceBy);
+var _set__default = /*#__PURE__*/_interopDefault(_set);
+var _findIndex__default = /*#__PURE__*/_interopDefault(_findIndex);
+var _isFinite__default = /*#__PURE__*/_interopDefault(_isFinite);
+var _max__default = /*#__PURE__*/_interopDefault(_max);
+var _flatMap__default = /*#__PURE__*/_interopDefault(_flatMap);
+var _without__default = /*#__PURE__*/_interopDefault(_without);
+var _union__default = /*#__PURE__*/_interopDefault(_union);
+var _update__default = /*#__PURE__*/_interopDefault(_update);
+var _flow__default = /*#__PURE__*/_interopDefault(_flow);
+var ReactDOM__default = /*#__PURE__*/_interopDefault(ReactDOM);
+var styled__default = /*#__PURE__*/_interopDefault(styled);
+var _isFunction__default = /*#__PURE__*/_interopDefault(_isFunction);
+var _get__default = /*#__PURE__*/_interopDefault(_get);
+var _isArray__default = /*#__PURE__*/_interopDefault(_isArray);
+var _isString__default = /*#__PURE__*/_interopDefault(_isString);
+var mitt__default = /*#__PURE__*/_interopDefault(mitt);
+var _isPlainObject__default = /*#__PURE__*/_interopDefault(_isPlainObject);
+var _identity__default = /*#__PURE__*/_interopDefault(_identity);
+
+const not_defined = {};
+const useConstant = value => {
+  const ref = React.useRef(not_defined);
+  if (ref.current === not_defined) {
+    ref.current = value;
+  }
+  return ref.current;
+};
+const useLazyConstant = value => {
+  const ref = React.useRef(not_defined);
+  if (ref.current === not_defined) {
+    ref.current = utils.callIfFunction(value);
+  }
+  return ref.current;
+};
+
+const callList = function (list, firstArg) {
+  for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    args[_key - 2] = arguments[_key];
+  }
+  return list.map(_ref => {
+    let current = _ref.current;
+    return typeof firstArg === 'function' ? firstArg(current) : current(firstArg, ...args);
+  });
+};
+const willUseSharedCallback = function () {
+  let useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React__default["default"].useEffect;
+  let mountedCallbacks = [];
+  let listenerCallbacks = [];
+  const remove = ref => mountedCallbacks = mountedCallbacks.filter(_ => _ !== ref);
+  const add = ref => mountedCallbacks = mountedCallbacks.concat([ref]);
+  const get = () => mountedCallbacks;
+  const removeListener = ref => listenerCallbacks = listenerCallbacks.filter(_ => _ !== ref);
+  const addListener = ref => listenerCallbacks = listenerCallbacks.concat([ref]);
+  const getListeners = ref => listenerCallbacks;
+  const lastCall = {
+    current: null,
+    index: 0
+  };
+  const call = function () {
+    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+      args[_key2] = arguments[_key2];
+    }
+    const resp = callList(get(), ...args);
+    callList(getListeners(), ...args);
+    lastCall.current = args;
+    lastCall.index++;
+    return resp;
+  };
+  const getSize = () => get().length;
+  const useRegister = function (callback) {
+    let listener = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+    const ref = React.useRef(callback);
+    if (ref.current !== callback) {
+      ref.current = callback;
+    }
+    const lastCallIndex = lastCall.index;
+    useEffect(() => {
+      if (!ref.current) {
+        return;
+      }
+      if (listener) {
+        addListener(ref);
+      } else {
+        add(ref);
+        if (lastCallIndex !== lastCall.index && lastCall.current) {
+          callList([ref], ...lastCall.current);
+        }
+      }
+      return () => {
+        if (listener) {
+          removeListener(ref);
+        } else {
+          remove(ref);
+        }
+      };
+    }, []);
+    return () => get().indexOf(ref);
+  };
+  return [useRegister, call, getSize];
+};
+
+const notDefined = {};
+const willUseSharedState = initialValue => {
+  const _willUseSharedCallbac = willUseSharedCallback(),
+    _willUseSharedCallbac2 = _slicedToArray__default["default"](_willUseSharedCallbac, 3),
+    useRegisterGroupCallback = _willUseSharedCallbac2[0],
+    callGroup = _willUseSharedCallbac2[1];
+    _willUseSharedCallbac2[2];
+  let sharedValue = utils.ifUndefined(initialValue, notDefined);
+  const setGroupState = newValue => {
+    sharedValue = utils.callIfFunction(newValue, sharedValue);
+    callGroup(sharedValue);
+  };
+  const refState = () => {
+    useRegisterGroupCallback();
+    return [() => sharedValue, setGroupState];
+  };
+  const valueState = defaultValue => {
+    const prevValue = sharedValue !== notDefined ? sharedValue : defaultValue;
+    if (prevValue === defaultValue) {
+      sharedValue = defaultValue;
+    }
+    const _useState = React.useState(prevValue),
+      _useState2 = _slicedToArray__default["default"](_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+    useRegisterGroupCallback(setValue);
+    return [value, setGroupState];
+  };
+  const clear = () => {
+    sharedValue = notDefined;
+  };
+  return [valueState, refState, setGroupState, () => sharedValue, clear];
+};
+
+const _excluded$1 = ["name", "children"];
+function ownKeys$4(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$4(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$4(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$4(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const SlotContext = /*#__PURE__*/React__default["default"].createContext(new Map());
+const _willUseSharedState = willUseSharedState(),
+  _willUseSharedState2 = _slicedToArray__default["default"](_willUseSharedState, 2),
+  useFillHookState = _willUseSharedState2[0],
+  useFillHookStateRef = _willUseSharedState2[1];
+const _willUseSharedState3 = willUseSharedState(),
+  _willUseSharedState4 = _slicedToArray__default["default"](_willUseSharedState3, 2),
+  useHiddenFillHookState = _willUseSharedState4[0],
+  useHiddenFillHookStateRef = _willUseSharedState4[1];
+const DEFAULT_CONTEXT = new Map();
+const SlotProvider = _ref => {
+  let children = _ref.children;
+  return /*#__PURE__*/React__default["default"].createElement(SlotContext.Provider, {
+    value: DEFAULT_CONTEXT
+  }, children, /*#__PURE__*/React__default["default"].createElement(React__default["default"].Suspense, {
+    fallback: null
+  }, /*#__PURE__*/React__default["default"].createElement(FillHooks, null)), /*#__PURE__*/React__default["default"].createElement(HiddenFillHooks, null));
+};
+const Slot = _ref2 => {
+  let name = _ref2.name,
+    children = _ref2.children,
+    rest = _objectWithoutProperties__default["default"](_ref2, _excluded$1);
+  const ref = React.useRef();
+  const slotInfo = useConstant({
+    ref
+  });
+  const slots = React.useContext(SlotContext);
+  React.useLayoutEffect(() => {
+    const previous = slots.get(name);
+    const updates = (previous === null || previous === void 0 ? void 0 : previous.updates) || [];
+    if (previous !== null && previous !== void 0 && previous.children) ;
+    slots.set(name, _flow__default["default"](_update__default["default"]('infos', _union__default["default"]([slotInfo])))(previous));
+    updates.forEach(v => v({}));
+    return () => {
+      var _previous$infos, _previous$updates;
+      const previous = slots.get(name);
+      previous.infos = _without__default["default"]([slotInfo], previous.infos);
+      if (!((_previous$infos = previous.infos) !== null && _previous$infos !== void 0 && _previous$infos.length) && !((_previous$updates = previous.updates) !== null && _previous$updates !== void 0 && _previous$updates.length)) {
+        slots.delete(name);
+      }
+    };
+  }, [name]);
+  return children ? /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, /*#__PURE__*/React__default["default"].createElement("div", _extends__default["default"]({
+    "data-id": name
+  }, rest, {
+    ref: ref
+  })), React__default["default"].Children.map(children, c => /*#__PURE__*/React__default["default"].cloneElement(c, _objectSpread$4(_objectSpread$4({}, c.props), {}, {
+    name,
+    stack: Number.MIN_SAFE_INTEGER
+  })))) : /*#__PURE__*/React__default["default"].createElement("div", _extends__default["default"]({
+    "data-id": name
+  }, rest, {
+    ref: ref
+  }));
+};
+const Invisible = /*#__PURE__*/styled__default["default"].div.withConfig({
+  displayName: "SlotFill__Invisible",
+  componentId: "h3oh7r-0"
+})(["display:none"]);
+const FillBeforeFlip = _ref3 => {
+  let name = _ref3.name,
+    children = _ref3.children;
+    _ref3.slot;
+  const slots = React.useContext(SlotContext);
+  const ref = React.useRef();
+  React.useLayoutEffect(() => {
+    var _slots$get;
+    const infos = ((_slots$get = slots.get(name)) === null || _slots$get === void 0 ? void 0 : _slots$get.infos) || [];
+    const mounted = _flatMap__default["default"](_ref4 => {
+      let ref = _ref4.ref;
+      return ref === null || ref === void 0 ? void 0 : ref.current;
+    }, infos);
+    const clones = [];
+    const getClone = () => {
+      const cloned = ref.current.cloneNode(true);
+      cloned.className = 'JS-fill-flip';
+      clones.push(cloned);
+      return cloned;
+    };
+    mounted.map(_ => _.appendChild(getClone()));
+    return () => {
+      clones.forEach(el => el.remove());
+    };
+  }, []);
+  return /*#__PURE__*/React__default["default"].createElement(Invisible, {
+    ref: ref
+  }, children);
+};
+const useFillState = (name, stack) => {
+  const forceUpdate = React__default["default"].useState(false)[1];
+  const slots = React.useContext(SlotContext);
+  const renderSlot = slots.get(name);
+  const maxStack = _max__default["default"](renderSlot === null || renderSlot === void 0 ? void 0 : renderSlot.stacks);
+  const onStack = !_isFinite__default["default"](maxStack) || maxStack === stack;
+  React.useLayoutEffect(() => {
+    const slot = slots.get(name);
+    const updatedSlot = _flow__default["default"](_update__default["default"]('updates', _union__default["default"]([forceUpdate])), _update__default["default"]('stacks', _union__default["default"]([stack])))(slot);
+    slots.set(name, updatedSlot);
+    updatedSlot.updates.forEach(v => v({}));
+    return () => {
+      const previous = slots.get(name);
+      const index = previous.updates.indexOf(forceUpdate);
+      const next = _flow__default["default"](_update__default["default"]('updates', utils._s.removeAt(index)), _update__default["default"]('stacks', utils._s.removeAt(index)))(previous);
+      slots.set(name, next);
+      next.updates.forEach(v => v({}));
+    };
+  }, []);
+  return [renderSlot, onStack];
+};
+const Fill = _ref5 => {
+  let name = _ref5.name,
+    children = _ref5.children,
+    _ref5$stack = _ref5.stack,
+    stack = _ref5$stack === void 0 ? 0 : _ref5$stack,
+    mountBeforeFlip = _ref5.mountBeforeFlip;
+  const _useFillState = useFillState(name, stack),
+    _useFillState2 = _slicedToArray__default["default"](_useFillState, 2),
+    slot = _useFillState2[0],
+    onStack = _useFillState2[1];
+  if (slot !== null && slot !== void 0 && slot.infos && onStack) {
+    return slot === null || slot === void 0 ? void 0 : slot.infos.map(info => {
+      var _info$ref;
+      return ((_info$ref = info.ref) === null || _info$ref === void 0 ? void 0 : _info$ref.current) && /*#__PURE__*/ReactDOM__default["default"].createPortal(utils.callIfFunction(children, info), info.ref.current);
+    });
+  } else if (mountBeforeFlip) {
+    return /*#__PURE__*/React__default["default"].createElement(FillBeforeFlip, {
+      name: name,
+      slot: slot
+    }, children);
+  } else {
+    return null;
+  }
+};
+const FillHooks = _ref6 => {
+  _objectDestructuringEmpty__default["default"](_ref6);
+  const _useFillHookState = useFillHookState({}),
+    _useFillHookState2 = _slicedToArray__default["default"](_useFillHookState, 1),
+    hooked = _useFillHookState2[0];
+  return Object.entries(hooked).map(_ref7 => {
+    let _ref8 = _slicedToArray__default["default"](_ref7, 2),
+      name = _ref8[0],
+      childs = _ref8[1];
+    return childs.map((_ref9, i) => {
+      let children = _ref9.children;
+      return /*#__PURE__*/React__default["default"].createElement(Fill, {
+        key: name + i,
+        name: name
+      }, children);
+    });
+  });
+};
+let uid = 0;
+const useFill = (name, children, inputs) => {
+  const _useFillHookStateRef = useFillHookStateRef(),
+    _useFillHookStateRef2 = _slicedToArray__default["default"](_useFillHookStateRef, 2),
+    set = _useFillHookStateRef2[1];
+  const key = React.useRef(uid++);
+  React.useLayoutEffect(() => {
+    if (children) {
+      set(_update__default["default"]([name], function () {
+        let list = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+        const index = _findIndex__default["default"](['key', key.current], list);
+        const value = {
+          children,
+          key: key.current
+        };
+        if (index >= 0) {
+          return _set__default["default"]([index], value, list);
+        } else {
+          return list.concat(value);
+        }
+      }));
+    } else {
+      set(_update__default["default"]([name], _differenceBy__default["default"]('key', _differenceBy__default["default"].placeholder, [{
+        children,
+        key: key.current
+      }])));
+    }
+  }, inputs || children);
+  React.useLayoutEffect(() => () => set(_update__default["default"]([name], _differenceBy__default["default"]('key', _differenceBy__default["default"].placeholder, [{
+    key: key.current
+  }]))), []);
+};
+const HiddenFillHooks = _ref0 => {
+  _objectDestructuringEmpty__default["default"](_ref0);
+  const _useHiddenFillHookSta = useHiddenFillHookState({}),
+    _useHiddenFillHookSta2 = _slicedToArray__default["default"](_useHiddenFillHookSta, 1),
+    hookedChildren = _useHiddenFillHookSta2[0];
+  return /*#__PURE__*/React__default["default"].createElement("div", null, Object.values(hookedChildren));
+};
+const useHiddenFill = (children, inputs) => {
+  const _useHiddenFillHookSta3 = useHiddenFillHookStateRef(),
+    _useHiddenFillHookSta4 = _slicedToArray__default["default"](_useHiddenFillHookSta3, 2),
+    set = _useHiddenFillHookSta4[1];
+  const _useMemo = React.useMemo(() => _uniqueId__default["default"](""), []),
+    _useMemo2 = _slicedToArray__default["default"](_useMemo, 1),
+    uid = _useMemo2[0];
+  set(_set__default["default"]([uid], children ? /*#__PURE__*/React__default["default"].cloneElement(children, {
+    key: uid
+  }) : null));
+  React.useEffect(() => () => set(_unset__default["default"]([uid])), []);
+};
+
+const useCallState = (defaultValue, setCallback) => {
+  const _useState = React.useState(defaultValue),
+    _useState2 = _slicedToArray__default["default"](_useState, 2),
+    val = _useState2[0],
+    setValue = _useState2[1];
+  return React.useMemo(() => {
+    const get = () => val;
+    return {
+      get,
+      val,
+      set: setValue
+    };
+  }, [val]);
+};
+
+const useIsUnmounted = () => {
+  const unmounted = React.useRef(false);
+  React.useEffect(() => {
+    unmounted.current = false;
+    return () => {
+      unmounted.current = true;
+    };
+  }, []);
+  return () => unmounted.current;
+};
+
+const isPath = path => typeof path === 'string' || typeof path === 'number' || Array.isArray(path);
+const getter = value => path => path !== "" && isPath(path) ? utils._s.get(path, value) : value;
+const uninitialized = {};
+const useRefState = (defaultValue, setCallback) => {
+  const ref = React.useRef(uninitialized);
+  if (ref.current === uninitialized) {
+    ref.current = utils.callIfFunction(defaultValue);
+  }
+  return React.useMemo(() => {
+    const get = path => getter(ref.current)(path);
+    const set = (v, config) => {
+      const prev = ref.current;
+      ref.current = utils.callIfFunctions(v, () => get());
+      if (prev !== ref.current && (!config || !config.ignoreCallback)) {
+        utils.callIfFunction(setCallback, prev, ref.current);
+      }
+    };
+    return {
+      get,
+      set
+    };
+  }, []);
+};
+
+function ownKeys$3(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$3(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$3(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$3(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const useToggleInternal = function () {
+  let startWith = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  let useStore = arguments.length > 1 ? arguments[1] : undefined;
+  let callback = arguments.length > 2 ? arguments[2] : undefined;
+  let key = arguments.length > 3 ? arguments[3] : undefined;
+  const isOpen = useStore(startWith);
+  const closing = useStore(false);
+  const refIsOpen = useRefState(isOpen.get());
+  const refIsClosing = useRefState(closing.get());
+  const timerId = React.useRef();
+  const isUnmounted = useIsUnmounted();
+  const clearClosing = () => {
+    if (refIsClosing.get() !== false) {
+      closing.set(false);
+      refIsClosing.set(false);
+      window.clearTimeout(timerId.current);
+    }
+  };
+  const toggleWith = function () {
+    let value = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    const calledValue = utils.callIfFunction(value, refIsOpen.get());
+    const newValue = refIsOpen.get() === calledValue ? !calledValue : calledValue;
+    if (!isUnmounted() && refIsOpen.get() !== newValue) {
+      const result = utils.callIfFunction(callback, newValue, refIsOpen.get());
+      if (result === false) {
+        return;
+      }
+      isOpen.set(newValue);
+      refIsOpen.set(newValue);
+      clearClosing();
+    }
+  };
+  const openWith = value => {
+    if (process.env.NODE_ENV !== 'production' && key) {
+      console.log(key, refIsOpen.get() !== value ? "toggle" : "clear", refIsOpen.get(), value);
+    }
+    const nextValue = utils.callIfFunction(value, refIsOpen.get());
+    if (refIsOpen.get() !== nextValue) {
+      toggleWith(() => nextValue);
+    } else {
+      clearClosing();
+    }
+  };
+  const nextClosingTick = (ticks, tickIndex) => {
+    if (ticks.length) {
+      if (isNaN(ticks[0])) {
+        clearClosing();
+      } else if (!isNaN(ticks[0])) {
+        closing.set(tickIndex + 1);
+        refIsClosing.set(tickIndex + 1);
+        timerId.current = setTimeout(() => nextClosingTick(ticks.slice(1), tickIndex + 1), Number(ticks[0]));
+      }
+    } else {
+      openWith(false);
+    }
+  };
+  const closeAfter = function () {
+    if (process.env.NODE_ENV !== 'production' && key) {
+      console.log(key, !refIsOpen.get() || refIsClosing.get() ? "addCLosing" : "closing");
+    }
+    if (!refIsOpen.get() || refIsClosing.get()) return;
+    for (var _len = arguments.length, millisecs = new Array(_len), _key = 0; _key < _len; _key++) {
+      millisecs[_key] = arguments[_key];
+    }
+    nextClosingTick(millisecs, 0);
+  };
+  const _wait = function (promise) {
+    let start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+    let end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    return async function () {
+      openWith(start);
+      try {
+        for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+          args[_key2] = arguments[_key2];
+        }
+        return await utils.callIfFunction(promise, ...args);
+      } finally {
+        openWith(end);
+      }
+    };
+  };
+  const setters = React.useMemo(() => ({
+    wait: function (promise) {
+      let start = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+      let end = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      return _wait(promise, start, end)();
+    },
+    willWait: _wait,
+    open: e => {
+      if (process.env.NODE_ENV !== 'production') {
+        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"));
+        }
+      }
+      return openWith(true);
+    },
+    close: () => openWith(false),
+    toggle: e => {
+      if (process.env.NODE_ENV !== 'production') {
+        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"));
+        }
+      }
+      toggleWith(true);
+    },
+    willOpenWith: value => () => openWith(value),
+    willCloseAfter: function () {
+      for (var _len3 = arguments.length, millsecs = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+        millsecs[_key3] = arguments[_key3];
+      }
+      return () => closeAfter(...millsecs);
+    },
+    willToggleWith: value => () => toggleWith(value),
+    openWith,
+    closeAfter,
+    toggleWith,
+    get: refIsOpen.get
+  }), []);
+  const settersWithNewRef = _objectSpread$3({}, setters);
+  if (closing.val) {
+    return Object.assign(settersWithNewRef, {
+      isOpen: isOpen.val,
+      closing: closing.val
+    });
+  } else {
+    Object.defineProperties(settersWithNewRef, {
+      isOpen: {
+        enumerable: true,
+        get: isOpen.get
+      },
+      closing: {
+        enumerable: true,
+        get: closing.get
+      }
+    });
+    return settersWithNewRef;
+  }
+};
+const useToggle = (startWith, callback, key) => useToggleInternal(startWith, useCallState, callback, key);
+const useRefToggle = startWith => useToggleInternal(startWith, useRefState);
+
+let prevOpenToggleClose = () => {};
+let sameTick = false;
+const clearPopups = () => {
+  if (!sameTick) {
+    prevOpenToggleClose();
+    prevOpenToggleClose = () => {};
+  }
+};
+const usePopupToggle = (startWith, callback) => {
+  const toggle = useToggle(startWith, (v, prev) => {
+    const result = utils.callIfFunction(callback, v, prev);
+    if (result === false) {
+      return false;
+    }
+    if (v !== false && prevOpenToggleClose !== toggle.close) {
+      prevOpenToggleClose();
+      prevOpenToggleClose = toggle.close;
+      sameTick = true;
+      window.setTimeout(() => sameTick = false, 1);
+    }
+    if (v === false) {
+      prevOpenToggleClose = () => {};
+    }
+  });
+  return toggle;
+};
+
+const StartlibsContext = /*#__PURE__*/React__default["default"].createContext({});
+const PopupContext = /*#__PURE__*/React__default["default"].createContext({});
+const StartlibsMetacontext = /*#__PURE__*/React__default["default"].createContext(() => {});
+const StartlibsConsumer = StartlibsContext.Consumer;
+const wrappeStyle = {
+  height: '100%'
+};
+class StartlibsProvider extends React__default["default"].Component {
+  constructor() {
+    super(...arguments);
+    this.openToggles = new Map();
+    this.popupToggleRender = (_ref, ref) => {
+      let isOpen = _ref.isOpen,
+        close = _ref.close;
+      if (isOpen && !this.openToggles.has(ref)) {
+        this.closePopup();
+        this.openToggles.set(ref, close);
+      }
+    };
+    this.closePopup = () => {
+      clearPopups();
+    };
+    this.startlibsMeta = new Map();
+    this.getMeta = (key, initValue) => {
+      const exists = this.startlibsMeta.get(key);
+      if (exists) return exists;
+      this.startlibsMeta.set(key, utils.callIfFunction(initValue));
+      return initValue;
+    };
+  }
+  componentDidMount() {
+    utils.fixMediaQuery();
+    const addVHFix = () => {
+      var _document$documentEle;
+      let vh = window.innerHeight * 0.01;
+      (_document$documentEle = document.documentElement) === null || _document$documentEle === void 0 || (_document$documentEle = _document$documentEle.style) === null || _document$documentEle === void 0 || _document$documentEle.setProperty('--vh', "".concat(vh, "px"));
+    };
+    window.addEventListener('resize', _debounce__default["default"](200, addVHFix));
+    addVHFix();
+  }
+  render() {
+    return /*#__PURE__*/React__default["default"].createElement(StartlibsContext.Provider, {
+      value: this.props.value
+    }, /*#__PURE__*/React__default["default"].createElement(StartlibsMetacontext.Provider, {
+      value: this.getMeta
+    }, /*#__PURE__*/React__default["default"].createElement(PopupContext.Provider, {
+      value: this.popupToggleRender
+    }, /*#__PURE__*/React__default["default"].createElement("div", {
+      style: wrappeStyle,
+      onClick: this.closePopup
+    }, /*#__PURE__*/React__default["default"].createElement(SlotProvider, null, this.props.children)))));
+  }
+}
+
+const willUseLayers = function () {
+  let useEffect = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : React__default["default"].useEffect;
+  const _willUseSharedCallbac = willUseSharedCallback(useEffect),
+    _willUseSharedCallbac2 = _slicedToArray__default["default"](_willUseSharedCallbac, 3),
+    useRegisterSharedCallback = _willUseSharedCallbac2[0],
+    callGroup = _willUseSharedCallbac2[1],
+    getSize = _willUseSharedCallbac2[2];
+  const useLayer = function () {
+    let _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+      onFirst = _ref.onFirst,
+      onEmpty = _ref.onEmpty,
+      onTop = _ref.onTop,
+      onRemove = _ref.onRemove;
+    let listener = arguments.length > 1 ? arguments[1] : undefined;
+    const resetIndex = React.useCallback(() => {
+      setIndex(getIndex());
+      if (getIndex() + 1 === getSize()) {
+        utils.callIfFunction(onTop, getIndex);
+      }
+    }, []);
+    const getIndex = useRegisterSharedCallback(resetIndex, listener);
+    const _useState = React.useState(getIndex()),
+      _useState2 = _slicedToArray__default["default"](_useState, 2),
+      index = _useState2[0],
+      setIndex = _useState2[1];
+    useEffect(() => {
+      if (getIndex() === 0) {
+        utils.callIfFunction(onFirst);
+      }
+      resetIndex();
+      return () => {
+        utils.callIfFunction(onRemove, getSize());
+        if (getSize() === 0) {
+          utils.callIfFunction(onEmpty);
+        }
+        callGroup();
+      };
+    }, []);
+    return [index, {
+      isFirst: () => getIndex() === 1,
+      isTop: () => getIndex() === getSize() - 1,
+      isEmpty: () => getSize() === 0,
+      getSize: () => getSize()
+    }];
+  };
+  return [useLayer, getSize];
+};
+
+const useConsumerCatalog = (mountCallback, unmountCallback) => {
+  const elements = useRefState([]);
+  const register = utils.callMany(element => elements.set(elements => elements.concat([element])), mountCallback);
+  const unregister = utils.callMany(element => elements.set(elements => elements.filter(_ => _ !== element)), unmountCallback);
+  const manager = React.useMemo(() => ({
+    register,
+    unregister
+  }), []);
+  return [elements.get, manager];
+};
+const useCatalogManager = (_ref, ref) => {
+  let register = _ref.register,
+    unregister = _ref.unregister;
+  React.useEffect(() => {
+    register(ref);
+    return () => unregister(ref);
+  }, [ref]);
+};
+
+const updateAllInputsState = (inputs, values) => {
+  const deferedUndefined = [];
+  inputs.forEach(input => {
+    const _input = _slicedToArray__default["default"](input, 2),
+      setValue = _input[0],
+      selector = _input[1];
+    const newValue = selector(values);
+    if (newValue === undefined) {
+      deferedUndefined.push([setValue, newValue]);
+    } else {
+      setValue(newValue);
+    }
+  });
+  deferedUndefined.forEach(_ref => {
+    let _ref2 = _slicedToArray__default["default"](_ref, 2),
+      set = _ref2[0],
+      value = _ref2[1];
+    return set(value);
+  });
+};
+const pathSelector = path => utils._s.get(path || []);
+const parsePathOrSelector = pathOrSelector => {
+  const isNotSelector = typeof pathOrSelector !== 'function';
+  if (isNotSelector) {
+    return [utils.formatPath(pathOrSelector), pathSelector(pathOrSelector)];
+  } else {
+    return ['', pathOrSelector];
+  }
+};
+const willUseSpreadState = function (defaultContextValue) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  const Context = /*#__PURE__*/React__default["default"].createContext(defaultContextValue);
+  const EMPTY_GLOBAL = {};
+  let prevInitState = EMPTY_GLOBAL;
+  let globalState = EMPTY_GLOBAL;
+  const getGlobalState = key => _isString__default["default"](key) || _isArray__default["default"](key) ? _get__default["default"](key, globalState) : globalState;
+  const useProvideSpreadState = (initState, setCallback) => {
+    const _useConsumerCatalog = useConsumerCatalog(input => updateAllInputsState([input], state.get())),
+      _useConsumerCatalog2 = _slicedToArray__default["default"](_useConsumerCatalog, 2),
+      consumerList = _useConsumerCatalog2[0],
+      manager = _useConsumerCatalog2[1];
+    const state = useRefState(initState, setCallback);
+    if (options.initRefCheck) {
+      if (prevInitState !== initState) {
+        globalState = initState;
+      }
+      prevInitState = initState;
+    }
+    if (globalState === EMPTY_GLOBAL) {
+      globalState = initState;
+    }
+    React.useEffect(() => {
+      globalState = state.get();
+    }, []);
+    const setState = (newState, fastPath, config) => {
+      // console.log("Fastpath noop:"+fastPath)
+      state.set(newState, config);
+      globalState = state.get();
+      updateAllInputsState(consumerList(), state.get());
+    };
+    const contextValue = React.useMemo(() => [state.get, setState, manager], []);
+    return [Context.Provider, contextValue, [state.get, setState]];
+  };
+  const useSpreadState = (pathOrSelector, inputs) => {
+    const _useContext = React.useContext(Context),
+      _useContext2 = _slicedToArray__default["default"](_useContext, 3),
+      getSpreadState = _useContext2[0],
+      setSpreadState = _useContext2[1],
+      manager = _useContext2[2];
+    const _parsePathOrSelector = parsePathOrSelector(pathOrSelector),
+      _parsePathOrSelector2 = _slicedToArray__default["default"](_parsePathOrSelector, 2),
+      path = _parsePathOrSelector2[0],
+      selector = _parsePathOrSelector2[1];
+    const pathOrInput = [path] || inputs || [];
+    const _useState = React.useState(selector(getSpreadState())),
+      _useState2 = _slicedToArray__default["default"](_useState, 2),
+      value = _useState2[0],
+      setValue = _useState2[1];
+    const isUnmounted = useIsUnmounted();
+    const currentPath = useRefState(path);
+    if (path !== currentPath.get()) {
+      /* when path changes, the consumerCatalogCallback will update the new value
+      *  another solution would be to call setValue here directly
+      *  the return value will still be the old, but will be changed before render, just like getDerivedStateFromProps
+      *
+      *  if there's a need for the return value to be the same, the value or, if enters here new value,
+      *  can be returned in an temp variable
+      * */
+      currentPath.set(path);
+    }
+    const input = React.useMemo(() => [v => {
+      /* noop for elements that may be unregistered while looping through consumerList */
+      if (path === currentPath.get() && !isUnmounted()) {
+        setValue(v);
+      }
+    }, selector], pathOrInput);
+    useCatalogManager(manager, input);
+    const setState = React.useCallback(v => setSpreadState((_isFunction__default["default"](v) ? pathOrSelector === undefined ? () => v : _update__default["default"] : _set__default["default"])(path, v), path), pathOrInput);
+    const getValue = () => selector(getGlobalState());
+    return [value, setState, getValue];
+  };
+  return [useProvideSpreadState, useSpreadState, Context, getGlobalState];
+};
+
+function ownKeys$2(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$2(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$2(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const propsOrConsume = (prop, Consumer, childrenAsFunction) => prop ? childrenAsFunction(prop) : /*#__PURE__*/React__default["default"].createElement(Consumer, null, childrenAsFunction);
+const addConsumers = (Component, obj) => Object.entries(obj).reduce((acc, _ref) => {
+  let _ref2 = _slicedToArray__default["default"](_ref, 2),
+    propKey = _ref2[0],
+    Consumer = _ref2[1];
+  return props => propsOrConsume(props[propKey], Consumer, v => acc(_objectSpread$2({
+    [propKey]: v
+  }, props)));
+}, props => /*#__PURE__*/React__default["default"].createElement(Component, props));
+const consumes = obj => Component => {
+  const withConsumers = addConsumers(Component, obj);
+  return props => withConsumers(props);
+};
+
+const withDialogError = Dialog => {
+  const ErrorBoundedComponent = /*#__PURE__*/React__default["default"].forwardRef((props, ref) => {
+    return /*#__PURE__*/React__default["default"].createElement(Dialog, _extends__default["default"]({
+      ref: ref
+    }, props));
+
+    // const ErrorBoundary = __internals('ErrorBoundary')
+    /*return (
+      <ErrorBoundary Error={props.Error || __internals('DialogError')} closeDialog={props.closeDialog}>
+        <Dialog {...props}/>
+      </ErrorBoundary>
+    )*/
+  });
+  // ErrorBoundedComponent.contextTypes = {startlibs:()=>null}
+  return ErrorBoundedComponent;
+};
+
+const GroupEventFactory = () => {
+  let emitter = mitt__default["default"]();
+  class WithGroupEvent extends React__default["default"].Component {
+    constructor() {
+      super(...arguments);
+      this.events = {};
+      this.processEvent = (type, event) => {
+        (this.events[type] || []).forEach(c => c(event));
+      };
+      this.groupEventProps = {
+        on: (type, callback) => {
+          this.events[type] = (this.events[type] || []).concat(callback);
+        },
+        off: (type, callback) => {
+          this.events[type] = (this.events[type] || []).filter(e => e !== callback);
+        },
+        emit: emitter.emit
+      };
+    }
+    componentDidMount() {
+      emitter.on('*', this.processEvent);
+    }
+    componentWillUnmount() {
+      emitter.off('*', this.processEvent);
+    }
+    render() {
+      return this.props.children(this.groupEventProps);
+    }
+  }
+  return WithGroupEvent;
+};
+const withGroupEvent = Component => {
+  const WithGroupEvent = GroupEventFactory();
+  return /*#__PURE__*/React__default["default"].forwardRef((props, ref) => /*#__PURE__*/React__default["default"].createElement(WithGroupEvent, null, groupEvent => /*#__PURE__*/React__default["default"].createElement(Component, _extends__default["default"]({}, props, {
+    ref: ref,
+    groupEvent: groupEvent
+  }))));
+};
+
+class WithRef extends React__default["default"].Component {
+  constructor(props) {
+    super(props);
+    const total = props.length || props.children.length;
+    const refs = new Array(total);
+    for (var i = 0; i < total; i++) {
+      refs[i] = /*#__PURE__*/React__default["default"].createRef();
+    }
+    this.createdRefs = refs;
+  }
+  render() {
+    const children = this.props.children;
+    return children(...this.createdRefs);
+  }
+}
+
+const _excluded = ["value", "fallback", "children", "forwardProps"],
+  _excluded2 = ["value", "wrap", "fallback", "children", "forwardProps"];
+function ownKeys$1(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const addExtraProp = function (element, extra) {
+  let override = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  return /*#__PURE__*/React__default["default"].cloneElement(element, override ? _objectSpread$1(_objectSpread$1({}, element.props), extra) : _objectSpread$1(_objectSpread$1({}, extra), element.props), element.props.children);
+};
+const WithLazyPlaceholder = _ref => {
+  let value = _ref.value,
+    fallback = _ref.fallback,
+    children = _ref.children,
+    _ref$forwardProps = _ref.forwardProps,
+    forwardProps = _ref$forwardProps === void 0 ? false : _ref$forwardProps,
+    props = _objectWithoutProperties__default["default"](_ref, _excluded);
+  return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Suspense, {
+    fallback: React__default["default"].Children.map(children(fallback, {
+      isLoading: true
+    }), child => /*#__PURE__*/React__default["default"].isValidElement(child) ? addExtraProp(child, {
+      isLoading: true
+    }, false) : child)
+  }, /*#__PURE__*/React__default["default"].createElement(Load, {
+    value: value,
+    children: children,
+    forwardProps: forwardProps && props
+  }));
+};
+const WithLazyResource = _ref2 => {
+  let value = _ref2.value,
+    wrap = _ref2.wrap,
+    fallback = _ref2.fallback,
+    children = _ref2.children,
+    _ref2$forwardProps = _ref2.forwardProps,
+    forwardProps = _ref2$forwardProps === void 0 ? false : _ref2$forwardProps,
+    props = _objectWithoutProperties__default["default"](_ref2, _excluded2);
+  return wrap || fallback !== undefined ? /*#__PURE__*/React__default["default"].createElement(React__default["default"].Suspense, {
+    fallback: utils.ifUndefined(fallback, null)
+  }, /*#__PURE__*/React__default["default"].createElement(Load, {
+    value: value,
+    forwardProps: forwardProps && props,
+    children: children
+  })) : /*#__PURE__*/React__default["default"].createElement(Load, {
+    value: value,
+    children: children,
+    forwardProps: forwardProps && props
+  });
+};
+const Load = _ref3 => {
+  let value = _ref3.value,
+    children = _ref3.children,
+    forwardProps = _ref3.forwardProps;
+  const loaded = _isArray__default["default"](value) ? value.forEach(v => v.promise()) || value.map(v => v.read()) : value.read();
+  const _useReducer = React.useReducer(s => s + 1, 0),
+    _useReducer2 = _slicedToArray__default["default"](_useReducer, 2),
+    update = _useReducer2[1];
+  const refresh = () => Promise.all(_isArray__default["default"](value) ? value.map(v => v.refresh().promise()) : [value.refresh().promise()]).then(update);
+  return forwardProps ? addExtraProp(children(loaded, {
+    refresh,
+    update
+  }), forwardProps) : children(loaded, {
+    refresh,
+    update
+  });
+};
+
+const useCallbackStable = fn => {
+  const ref = React__default["default"].useRef([fn, function () {
+    return ref[0](...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(() => {
+    ref[0] = fn;
+  });
+  return ref[1];
+};
+
+const WithEffect = _ref => {
+  let _ref$inputs = _ref.inputs,
+    inputs = _ref$inputs === void 0 ? [] : _ref$inputs,
+    children = _ref.children;
+  React.useEffect(children, inputs);
+  return null;
+};
+
+const _willUseLayers = willUseLayers(),
+  _willUseLayers2 = _slicedToArray__default["default"](_willUseLayers, 1),
+  useTitleLayers = _willUseLayers2[0];
+const useTitle = title => {
+  useTitleLayers({
+    onTop: () => {
+      document.title = title;
+    }
+  });
+};
+
+const TabFocus = /*#__PURE__*/styled__default["default"].div.withConfig({
+  displayName: "useRecycleFocus__TabFocus",
+  componentId: "kxnccs-0"
+})(["width:0;height:0;position:absolute;"]);
+const useRecycleFocus = function (ref) {
+  let enabled = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  let lastIndex = arguments.length > 2 ? arguments[2] : undefined;
+  const recycle = i => e => {
+    if (!enabled || !ref.current) {
+      return;
+    }
+    const nextTab = ref.current.querySelectorAll('[tabindex]');
+    if (nextTab) {
+      if (i < 0) {
+        console.log(nextTab[1]);
+        nextTab[1].focus();
+      } else {
+        console.log(nextTab[nextTab.length - 2]);
+        nextTab[nextTab.length - 2].focus();
+      }
+    }
+  };
+  return [/*#__PURE__*/React__default["default"].createElement(TabFocus, {
+    tabIndex: 1,
+    onFocus: recycle(0)
+  }), /*#__PURE__*/React__default["default"].createElement(TabFocus, {
+    tabIndex: lastIndex || 1,
+    onFocus: recycle(-1)
+  })];
+};
+
+function usePrevious(value, initialValue) {
+  const ref = React.useRef(initialValue);
+  React.useEffect(() => {
+    ref.current = value;
+  });
+  return ref.current;
+}
+function usePreviousUnique(value, initialValue) {
+  const ref = React.useRef(initialValue);
+  React.useEffect(() => {
+    if (value !== ref.current) {
+      ref.current = value;
+    }
+  });
+  return ref.current;
+}
+function usePreviousForEffect(value, initialValue) {
+  const ref = React.useRef(initialValue);
+  React.useEffect(() => () => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+
+const useEnsureRef = forwardedRef => {
+  const ref = React.useRef();
+  return forwardedRef || ref;
+};
+
+const useForceUpdate = () => {
+  const _useState = React.useState(0),
+    _useState2 = _slicedToArray__default["default"](_useState, 2);
+    _useState2[0];
+    const setValue = _useState2[1]; // integer state
+  return () => setValue(value => value + 1); // update the state to force render
+};
+const willUseForceUpdate = () => {
+  const _willUseSharedState = willUseSharedState(),
+    _willUseSharedState2 = _slicedToArray__default["default"](_willUseSharedState, 3),
+    useValue = _willUseSharedState2[0],
+    set = _willUseSharedState2[2];
+  const useForceUpdate = () => {
+    const _useValue = useValue(0),
+      _useValue2 = _slicedToArray__default["default"](_useValue, 2);
+      _useValue2[0];
+      const setV = _useValue2[1];
+    return () => setV(value => value + 1);
+  };
+  return [useForceUpdate, () => set(value => value + 1)];
+};
+
+const useUpdateOnResize = function () {
+  let debounceInterval = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 200;
+  const update = useForceUpdate();
+  React.useEffect(() => {
+    const trigger = _debounce__default["default"](debounceInterval, update);
+    window.addEventListener('resize', trigger);
+    return () => {
+      window.removeEventListener('resize', trigger);
+    };
+  }, []);
+};
+
+const useAsyncEffect = (fn, args) => {
+  React.useEffect(() => {
+    const result = fn();
+    return () => {
+      result.then(end => utils.callIfFunction(end));
+    };
+  }, args);
+};
+
+const useUpdateEffect = (effect, inputs) => {
+  const pastFirstTime = React.useRef();
+  React.useEffect(() => {
+    if (pastFirstTime.current) {
+      return effect();
+    } else {
+      pastFirstTime.current = true;
+    }
+  }, inputs);
+};
+
+const useRefMemo = value => {
+  const ref = React.useRef(value);
+  if (ref.current !== value) {
+    ref.current = utils.callIfFunction(value);
+  }
+  return ref;
+};
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty__default["default"](e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+const IS_ARRAY_ITEMS_EQUALS = (a, b) => a.length === b.length && !a.some((x, i) => !Object.is(x, b[i]));
+const IS_DEPS_EQUALS = function () {
+  let a = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  let b = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  return Object.is(a, b) || IS_ARRAY_ITEMS_EQUALS(a, b);
+};
+const SHALLOW_IS_EQUAL = (a, b) => Object.is(a, b) || _isArray__default["default"](a) && _isArray__default["default"](b) && IS_ARRAY_ITEMS_EQUALS(a, b);
+const EMPTY_DEPS = [];
+const EMPTY_VALUE = {
+  "EMPTY": true
+};
+const useUpdateSignal = initialValue => {
+  const value = React.useRef(initialValue);
+  value.current = initialValue;
+  return useLazyConstant(() => {
+    let registered = [];
+    const register = function () {
+      let selector = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : _identity__default["default"];
+      let isEqual = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : SHALLOW_IS_EQUAL;
+      let withTransition = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+      const selectorRef = React.useRef();
+      selectorRef.current = selector;
+      const update = useForceUpdate();
+      const lastValueRef = React.useRef(utils._s.select(selectorRef.current, value.current));
+      React.useEffect(() => {
+        const item = [update, selectorRef, isEqual, lastValueRef, withTransition];
+        registered = [...registered, item];
+        return () => {
+          registered = registered.filter(v => v !== item);
+        };
+      }, []);
+      if (value.current === EMPTY_VALUE) {
+        return EMPTY_VALUE;
+      }
+      return lastValueRef.current;
+    };
+    const call = function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return registered.forEach(_ref => {
+        let _ref2 = _slicedToArray__default["default"](_ref, 5),
+          fn = _ref2[0],
+          selectorRef = _ref2[1],
+          isEqual = _ref2[2],
+          lastValueRef = _ref2[3],
+          withTransition = _ref2[4];
+        const nextValue = utils._s.select(selectorRef.current, ...args);
+        if (!utils.callIfFunction(isEqual, nextValue, lastValueRef.current)) {
+          lastValueRef.current = nextValue;
+          if (withTransition) {
+            (withTransition === true ? React.startTransition : withTransition)(() => fn(nextValue));
+          } else {
+            fn(nextValue);
+          }
+        }
+      });
+    };
+    return [register, call];
+  });
+};
+const useSelectorSignal = value => {
+  const prevValue = React.useRef(value);
+  const _useUpdateSignal = useUpdateSignal(value),
+    _useUpdateSignal2 = _slicedToArray__default["default"](_useUpdateSignal, 2),
+    _register = _useUpdateSignal2[0],
+    call = _useUpdateSignal2[1];
+  const register = React.useCallback((selector, deps, isEqual, withTransition) => {
+    const prevDeps = React.useRef(EMPTY_DEPS);
+    if (prevDeps.current !== EMPTY_DEPS && !IS_DEPS_EQUALS(deps, prevDeps.current)) {
+      call(prevValue.current);
+    }
+    prevDeps.current = deps;
+    return _register(selector, isEqual, withTransition);
+  }, []);
+  React.useEffect(() => {
+    if (prevValue.current !== value) {
+      prevValue.current = value;
+      call(value);
+    }
+  }, [value]);
+  return register;
+};
+const updateStateFn = (path, update) => state => path ? _update__default["default"](path, v => utils.callIfFunction(update, v), state) : utils.callIfFunction(update, state);
+const createStatefulContext = (v, defaultIsEqual) => {
+  const Ctx = /*#__PURE__*/React__default["default"].createContext(v);
+  const Provider = _ref3 => {
+    let value = _ref3.value,
+      setValue = _ref3.setValue,
+      utils = _ref3.utils,
+      children = _ref3.children;
+    const register = useSelectorSignal(value);
+    const v = useLazyConstant(() => [register, setValue, utils]);
+    return /*#__PURE__*/React__default["default"].createElement(Ctx.Provider, {
+      value: v
+    }, children);
+  };
+  const useCtx = () => React.useContext(Ctx);
+  const useSelectValue = (selector, deps, defaultIsEqual, withTransition) => {
+    const _useCtx = useCtx(),
+      _useCtx2 = _slicedToArray__default["default"](_useCtx, 1),
+      useRegister = _useCtx2[0];
+    if (deps === true) {
+      return useRegister(selector, [], undefined, React.startTransition);
+    } else if (_isPlainObject__default["default"](deps)) {
+      return useRegister(selector, deps.deps, deps.isEqual, deps.withTransition);
+    } else {
+      return useRegister(selector, _isArray__default["default"](deps) ? deps : deps === null || deps === void 0 ? void 0 : deps.deps, defaultIsEqual, withTransition);
+    }
+  };
+  const useSetValue = path => {
+    const _useCtx3 = useCtx(),
+      _useCtx4 = _slicedToArray__default["default"](_useCtx3, 2);
+      _useCtx4[0];
+      const set = _useCtx4[1];
+    return useConstant(update => set(updateStateFn(path, update)));
+  };
+  const useUtils = (path, deps) => {
+    const _useCtx5 = useCtx(),
+      _useCtx6 = _slicedToArray__default["default"](_useCtx5, 3);
+      _useCtx6[0];
+      _useCtx6[1];
+      const utils = _useCtx6[2];
+    return utils;
+  };
+  return [Provider, [useSelectValue, useSetValue, useUtils, useCtx]];
+};
+const createSelfStatefulContext = (v, defaultIsEqual) => {
+  const _createStatefulContex = createStatefulContext(v),
+    _createStatefulContex2 = _slicedToArray__default["default"](_createStatefulContex, 2),
+    Provider = _createStatefulContex2[0],
+    _createStatefulContex3 = _slicedToArray__default["default"](_createStatefulContex2[1], 4),
+    useSelectValue = _createStatefulContex3[0],
+    useSetValue = _createStatefulContex3[1],
+    useUtils = _createStatefulContex3[2],
+    useCtx = _createStatefulContex3[3];
+  const StateFullProvider = _ref4 => {
+    let _ref4$init = _ref4.init,
+      init = _ref4$init === void 0 ? {} : _ref4$init,
+      utils = _ref4.utils,
+      children = _ref4.children;
+    const _useState = React.useState(init),
+      _useState2 = _slicedToArray__default["default"](_useState, 2),
+      state = _useState2[0],
+      setState = _useState2[1];
+    return /*#__PURE__*/React__default["default"].createElement(Provider, {
+      value: state,
+      setValue: setState,
+      utils: utils
+    }, children);
+  };
+  return [StateFullProvider, [useSelectValue, useSetValue, useUtils, useCtx]];
+};
+const createLazyStatefulContext = (toPromise, defaultIsEqual) => {
+  const _createStatefulContex4 = createStatefulContext(EMPTY_VALUE),
+    _createStatefulContex5 = _slicedToArray__default["default"](_createStatefulContex4, 2),
+    Provider = _createStatefulContex5[0],
+    _createStatefulContex6 = _slicedToArray__default["default"](_createStatefulContex5[1], 4),
+    useSelectValue = _createStatefulContex6[0];
+    _createStatefulContex6[1];
+    const useUtils = _createStatefulContex6[2],
+    useCtx = _createStatefulContex6[3];
+  const useSelectLazyValue = function (selector, deps) {
+    let isEqual = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : defaultIsEqual;
+    let withTransition = arguments.length > 3 ? arguments[3] : undefined;
+    const value = useSelectValue(selector, deps, isEqual, withTransition);
+    const utils$1 = useUtils();
+    if (value === EMPTY_VALUE) {
+      const loadedValue = React.use(utils$1._lazyValue());
+      return utils._s.select(selector, loadedValue);
+    }
+    return value;
+  };
+  const useSetLazyValue = path => {
+    const _useCtx7 = useCtx(),
+      _useCtx8 = _slicedToArray__default["default"](_useCtx7, 3),
+      setValue = _useCtx8[1],
+      utils = _useCtx8[2];
+    return useConstant(update => {
+      return setValue(value => value === EMPTY_VALUE ? updateStateFn(path, update)(utils.loadedValue()) : updateStateFn(path, update)(value));
+    });
+  };
+  const useValuePromise = (selector, deps, isEqual, withTransition) => {
+    const value = useSelectValue(selector, deps, isEqual, withTransition);
+    const utils$1 = useUtils();
+    return React.useCallback(() => {
+      if (value === EMPTY_VALUE) {
+        return utils$1._lazyValue().then(v => console.log(v, utils._s.select(selector, v), selector) || utils._s.select(selector, v));
+      }
+      return new Promise(value);
+    }, [value, deps]);
+  };
+  const LazyStateFullProvider = _ref5 => {
+    let value = _ref5.value,
+      utils$1 = _ref5.utils,
+      children = _ref5.children,
+      _ref5$fallback = _ref5.fallback,
+      fallback = _ref5$fallback === void 0 ? null : _ref5$fallback;
+    const _useState3 = React.useState(EMPTY_VALUE),
+      _useState4 = _slicedToArray__default["default"](_useState3, 2),
+      state = _useState4[0],
+      setState = _useState4[1];
+    const promise = React.useRef();
+    const loadedValue = React.useRef();
+    const lazyUtils = React.useMemo(() => _objectSpread(_objectSpread({}, utils$1), {}, {
+      _lazyValue: () => {
+        var _promise$current;
+        (_promise$current = promise.current) !== null && _promise$current !== void 0 ? _promise$current : promise.current = utils.callIfFunction(toPromise || _identity__default["default"], value);
+        promise.current.then(value => {
+          loadedValue.current = value;
+        });
+        return promise.current;
+      },
+      loadedValue: () => loadedValue.current
+    }), [value, utils$1]);
+    return /*#__PURE__*/React__default["default"].createElement(Provider, {
+      value: state,
+      setValue: setState,
+      utils: lazyUtils
+    }, fallback === false ? children : /*#__PURE__*/React__default["default"].createElement(React__default["default"].Suspense, {
+      fallback: fallback
+    }, children));
+  };
+  return [LazyStateFullProvider, [useSelectLazyValue, useSetLazyValue, useValuePromise]];
+};
+const createSelectableContext = v => {
+  const _createStatefulContex7 = createStatefulContext(v),
+    _createStatefulContex8 = _slicedToArray__default["default"](_createStatefulContex7, 2),
+    Provider = _createStatefulContex8[0],
+    _createStatefulContex9 = _slicedToArray__default["default"](_createStatefulContex8[1], 1),
+    useSelectValue = _createStatefulContex9[0];
+  return [Provider, useSelectValue];
+};
+const createTriggerUpdateContext = v => {
+  const _createStatefulContex0 = createStatefulContext(v),
+    _createStatefulContex1 = _slicedToArray__default["default"](_createStatefulContex0, 2),
+    Provider = _createStatefulContex1[0],
+    _createStatefulContex10 = _slicedToArray__default["default"](_createStatefulContex1[1], 1),
+    useSelectValue = _createStatefulContex10[0];
+  const TriggerProvider = /*#__PURE__*/React__default["default"].forwardRef((_ref6, ref) => {
+    let children = _ref6.children;
+    const _useState5 = React.useState(0),
+      _useState6 = _slicedToArray__default["default"](_useState5, 2),
+      v = _useState6[0],
+      setV = _useState6[1];
+    const trigger = React__default["default"].useMemo(() => () => setV(v => v + 1), [v]);
+    React__default["default"].useImperativeHandle(ref, () => ({
+      trigger
+    }), []);
+    return /*#__PURE__*/React__default["default"].createElement(Provider, {
+      value: trigger
+    }, children);
+  });
+  return [TriggerProvider, useSelectValue];
+};
+
+const WithConstant = _ref => {
+  _ref.inputs;
+    let value = _ref.value,
+    children = _ref.children;
+  const constant = useLazyConstant(value);
+  return children(constant);
+};
+
+const useWithTransition = value => {
+  const _useState = React.useState(value),
+    _useState2 = _slicedToArray__default["default"](_useState, 2),
+    state = _useState2[0],
+    setState = _useState2[1];
+  React.useEffect(() => {
+    React.startTransition(() => {
+      setState(value);
+    });
+  }, [value]);
+  return state;
+};
+
+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.createLazyStatefulContext = createLazyStatefulContext;
+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.useTitle = useTitle;
+exports.useToggle = useToggle;
+exports.useUpdateEffect = useUpdateEffect;
+exports.useUpdateOnResize = useUpdateOnResize;
+exports.useUpdateSignal = useUpdateSignal;
+exports.useWithTransition = useWithTransition;
+exports.willUseForceUpdate = willUseForceUpdate;
+exports.willUseLayers = willUseLayers;
+exports.willUseSharedCallback = willUseSharedCallback;
+exports.willUseSharedState = willUseSharedState;
+exports.willUseSpreadState = willUseSpreadState;
+exports.withDialogError = withDialogError;
+exports.withGroupEvent = withGroupEvent;
+//# sourceMappingURL=index.cjs.map