@lowentry/react-redux 1.15.4 → 2.0.1

package/dist/index.js

@@ -0,0 +1,1456 @@
+// src/LeRed.tsx
+import * as React from "react";
+import * as ReactDOM from "react-dom";
+import * as ReactRedux from "react-redux";
+import * as Redux from "redux";
+import * as RTK from "@reduxjs/toolkit";
+import * as ReduxSaga from "redux-saga";
+import * as ReduxSagaEffects from "redux-saga/effects";
+import { LeUtils, STRING, ISSET, ARRAY, IS_OBJECT, IS_ARRAY, INT_LAX_ANY } from "@lowentry/utils";
+import { Fragment, jsx } from "react/jsx-runtime";
+var fixEqualsComparator = (equalsComparator, errorMessage) => {
+  if (ISSET(equalsComparator)) {
+    if (typeof equalsComparator !== "function") {
+      console.error(errorMessage);
+      console.error(equalsComparator);
+      return LeUtils.equals;
+    }
+    return (a, b) => {
+      try {
+        return Boolean(equalsComparator(a, b));
+      } catch (e) {
+        console.error("LeRed: equalsComparator threw an error", e);
+        return false;
+      }
+    };
+  }
+  return LeUtils.equals;
+};
+var useCompareMemoize = (value, equalsComparator) => {
+  const ref = React.useRef(null);
+  if (!equalsComparator(value, ref.current)) {
+    ref.current = value;
+  }
+  return ref.current;
+};
+var useState2 = React.useState;
+var leRedUseSelector = (selector, equalsComparator) => {
+  if (typeof selector !== "function") {
+    console.error("LeRed.useSelector() was given an invalid selector:");
+    console.error(selector);
+    const fallbackSelector = () => void 0;
+    selector = fallbackSelector;
+  }
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.useSelector() was given an invalid comparator:");
+  return ReactRedux.useSelector(selector, validatedComparator);
+};
+var leRedUseLayoutEffect = (callable, comparingValues, equalsComparator) => {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.useLayoutEffect() was given an invalid comparator:");
+  const values = ARRAY(comparingValues);
+  const memoizedValues = values.map((value) => useCompareMemoize(value, validatedComparator));
+  return React.useLayoutEffect(callable, memoizedValues);
+};
+var leRedUseEffect = (callable, comparingValues, equalsComparator) => {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.useEffect() was given an invalid comparator:");
+  const values = ARRAY(comparingValues);
+  const memoizedValues = values.map((value) => useCompareMemoize(value, validatedComparator));
+  return React.useEffect(callable, memoizedValues);
+};
+var leRedUseMemo = (callable, comparingValues, equalsComparator) => {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.useMemo() was given an invalid comparator:");
+  const values = ARRAY(comparingValues);
+  const memoizedValues = values.map((value) => useCompareMemoize(value, validatedComparator));
+  return React.useMemo(callable, memoizedValues);
+};
+var leRedUseCallback = (callable, comparingValues, equalsComparator) => {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.useCallback() was given an invalid comparator:");
+  const values = ARRAY(comparingValues);
+  const memoizedValues = values.map((value) => useCompareMemoize(value, validatedComparator));
+  return React.useCallback(callable, memoizedValues);
+};
+var useEffect2 = leRedUseEffect;
+var useLayoutEffect2 = leRedUseLayoutEffect;
+var useCallback2 = leRedUseCallback;
+var useMemo2 = leRedUseMemo;
+var useContext2 = React.useContext;
+var useReducer2 = React.useReducer;
+var useRef2 = React.useRef;
+var useDebugValue2 = React.useDebugValue;
+function useImperativeHandle2(ref, createHandle, comparingValues, equalsComparator) {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.useImperativeHandle() was given an invalid comparator:");
+  const values = ARRAY(comparingValues ?? []);
+  const memoizedValues = values.map((value) => useCompareMemoize(value, validatedComparator));
+  return React.useImperativeHandle(ref, createHandle, memoizedValues);
+}
+function useDeferredValue2(value, equalsComparator) {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.useDeferredValue() was given an invalid comparator:");
+  const stableValue = useCompareMemoize(value, validatedComparator);
+  return React.useDeferredValue(stableValue);
+}
+var useTransition2 = React.useTransition;
+var useId2 = React.useId;
+var useInsertionEffect2 = (callable, comparingValues, equalsComparator) => {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.useInsertionEffect() was given an invalid comparator:");
+  const values = ARRAY(comparingValues);
+  const memoizedValues = values.map((value) => useCompareMemoize(value, validatedComparator));
+  return React.useInsertionEffect(callable, memoizedValues);
+};
+var useSyncExternalStore2 = React.useSyncExternalStore;
+var Children2 = React.Children;
+var createContext2 = React.createContext;
+var createElement2 = React.createElement;
+var cloneElement2 = React.cloneElement;
+var isValidElement2 = React.isValidElement;
+var lazy2 = React.lazy;
+var forwardRef2 = React.forwardRef;
+var leRedMemo = (component, equalsComparator) => {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.memo() was given an invalid comparator:");
+  return React.memo(component, validatedComparator);
+};
+var memo2 = leRedMemo;
+var startTransition2 = React.startTransition;
+var createPortal2 = ReactDOM.createPortal;
+var flushSync2 = ReactDOM.flushSync;
+var createReducer2 = RTK.createReducer;
+var createAsyncThunk2 = RTK.createAsyncThunk;
+var createEntityAdapter2 = RTK.createEntityAdapter;
+var nanoid2 = RTK.nanoid;
+var current2 = (obj) => {
+  try {
+    return RTK.current(obj);
+  } catch {
+  }
+  return obj;
+};
+var isImmutableDefault2 = RTK.isImmutableDefault;
+var unwrapResult2 = RTK.unwrapResult;
+var createNextState2 = RTK.createNextState;
+var produce = RTK.createNextState;
+var freeze2 = RTK.freeze;
+var isDraft2 = RTK.isDraft;
+var original2 = RTK.original;
+var combineSlices2 = RTK.combineSlices;
+var createListenerMiddleware2 = RTK.createListenerMiddleware;
+var createDynamicMiddleware2 = RTK.createDynamicMiddleware;
+var autoBatchEnhancer2 = RTK.autoBatchEnhancer;
+var isAnyOf2 = RTK.isAnyOf;
+var isAllOf2 = RTK.isAllOf;
+var isPending2 = RTK.isPending;
+var isFulfilled2 = RTK.isFulfilled;
+var isRejected2 = RTK.isRejected;
+var isAsyncThunkAction2 = RTK.isAsyncThunkAction;
+var isRejectedWithValue2 = RTK.isRejectedWithValue;
+var combineReducers2 = Redux.combineReducers;
+var applyMiddleware2 = Redux.applyMiddleware;
+var compose2 = Redux.compose;
+var bindActionCreators2 = Redux.bindActionCreators;
+var configureStore2 = (storeData) => {
+  if (!storeData || typeof storeData !== "object") {
+    storeData = {
+      reducer: (state = {}) => state
+    };
+  }
+  if (storeData.__lowentry_store__ === true) {
+    return storeData;
+  }
+  try {
+    if (ISSET(storeData.slices)) {
+      storeData.reducer = storeData.slices;
+      delete storeData.slices;
+    }
+  } catch (e) {
+    console.error("Failed to access slices on storeData:", e);
+  }
+  const sagaListeners = [];
+  const initialState = {};
+  if (ISSET(storeData.reducer)) {
+    let slices = storeData.reducer;
+    if (typeof slices === "object" && slices !== null) {
+      if ("name" in slices && slices.name || "__lowentry_unfinished_slice" in slices && slices.__lowentry_unfinished_slice) {
+        slices = [slices];
+      } else {
+        const slicesArray = [];
+        LeUtils.each(slices, (slice, index) => {
+          if (slice && (typeof slice === "object" || typeof slice === "function")) {
+            if (typeof slice === "function") {
+              slice = {
+                name: STRING(index),
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Legacy reducer function type
+                state: slice(void 0, { type: "@@INIT" }),
+                reducers: {
+                  [STRING(index)]: slice
+                }
+              };
+            }
+            const recordSlice = slice;
+            if (!("name" in recordSlice) || !recordSlice.name) {
+              recordSlice.name = STRING(index);
+            }
+            slicesArray.push(slice);
+          }
+        });
+        slices = slicesArray;
+      }
+    }
+    slices = ARRAY(slices);
+    const reducerArrays = {};
+    LeUtils.each(slices, (slice, index) => {
+      if (slice && typeof slice === "object") {
+        const recordSlice = slice;
+        if (!("name" in recordSlice) || !recordSlice.name) {
+          recordSlice.name = "slice_" + STRING(index);
+        }
+        const typedSlice = slice;
+        initialState[typedSlice.name] = typeof typedSlice.state === "function" ? typedSlice.state() : typedSlice.state;
+        LeUtils.each(typedSlice.reducers, (reducer, reducerName) => {
+          const fullReducerName = STRING(reducerName).startsWith("lowentrystore/") ? STRING(reducerName).substring("lowentrystore/".length) : typedSlice.name + "/" + STRING(reducerName);
+          if (typeof reducerArrays[fullReducerName] === "undefined") {
+            reducerArrays[fullReducerName] = [];
+          }
+          reducerArrays[fullReducerName].push(reducer);
+        });
+        LeUtils.each(typedSlice.sagaListeners, (sagaListener, reducerName) => {
+          LeUtils.each(LeUtils.flattenArray(sagaListener), (listener) => {
+            try {
+              if (typeof listener === "function") {
+                sagaListeners.push(listener());
+              }
+            } catch (e) {
+              console.error('an error was thrown by your saga code, in slice "' + typedSlice.name + '", action "' + STRING(reducerName) + '":');
+              console.error(e);
+            }
+          });
+        });
+      }
+    });
+    const reducers = {};
+    LeUtils.each(reducerArrays, (reducerArray, reducerName) => {
+      const flattenedArray = LeUtils.flattenArray(reducerArray);
+      const firstReducer = flattenedArray[0];
+      if (flattenedArray.length <= 1) {
+        if (typeof firstReducer === "function") {
+          reducers[STRING(reducerName)] = firstReducer;
+        }
+      } else {
+        reducers[STRING(reducerName)] = (...args) => {
+          LeUtils.each(flattenedArray, (reducer) => {
+            try {
+              if (typeof reducer === "function") {
+                reducer(...args);
+              }
+            } catch (e) {
+              console.error(e);
+            }
+          });
+        };
+      }
+    });
+    storeData.reducer = RTK.createSlice({
+      name: "lowentrystore",
+      initialState,
+      reducers
+    }).reducer;
+    if (!ISSET(storeData.preloadedState)) {
+      storeData.preloadedState = LeUtils.clone(initialState);
+    }
+  }
+  if (ISSET(storeData.state)) {
+    storeData.preloadedState = storeData.state;
+    delete storeData.state;
+  }
+  if (ISSET(storeData.preloadedState)) {
+    if (!storeData.reducer) {
+      storeData.reducer = (state) => state;
+    }
+    storeData.preloadedState = { reducer: storeData.preloadedState };
+  } else {
+    if (!storeData.reducer) {
+      storeData.reducer = (state) => state;
+    }
+    storeData.preloadedState = { reducer: LeUtils.clone(initialState) };
+  }
+  const middleware = ARRAY(storeData.middleware);
+  let sagaMiddleware = null;
+  if (sagaListeners.length > 0) {
+    sagaMiddleware = ReduxSaga.default();
+    middleware.push(sagaMiddleware);
+  }
+  storeData.middleware = (getDefaultMiddleware) => getDefaultMiddleware().concat(...middleware);
+  const store = RTK.configureStore({
+    ...storeData,
+    reducer: {
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- RTK reducer type
+      reducer: storeData.reducer
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  });
+  store.__lowentry_store__ = true;
+  store.state = () => store.getState().reducer;
+  const dispatch = store.dispatch;
+  store.dispatch = ((action) => {
+    const typedAction = action;
+    typedAction.__lowentry_dispatch__ = true;
+    if (STRING(action.type).startsWith("lowentrystore/")) {
+      typedAction.__lowentry_dispatch_result__ = [];
+    } else {
+      delete typedAction.__lowentry_dispatch_result__;
+    }
+    dispatch(action);
+    const result = typedAction.__lowentry_dispatch_result__;
+    delete typedAction.__lowentry_dispatch_result__;
+    delete typedAction.__lowentry_dispatch__;
+    return result;
+  });
+  if (sagaMiddleware !== null) {
+    sagaMiddleware.run(function* () {
+      yield ReduxSagaEffects.all(sagaListeners);
+    });
+  }
+  return store;
+};
+var createSlice2 = (slice) => {
+  if (!slice) {
+    return { __lowentry_unfinished_slice: true };
+  }
+  if (Array.isArray(slice)) {
+    const e = new Error("the given slice is an array (instead of an object)");
+    console.error("an error was thrown by your LeRed.createSlice(...) code:");
+    console.error(e);
+    throw e;
+  }
+  if (slice.name) {
+    const actions = {};
+    const reducers = {};
+    const sagas = {};
+    const sagaListeners = {};
+    LeUtils.each(slice.actions, (reducer, reducerNames) => {
+      LeUtils.each(STRING(reducerNames).split(","), (reducerName) => {
+        if (STRING(reducerName).length <= 0) {
+          return;
+        }
+        const reducerAction = RTK.createAction((STRING(reducerName).startsWith("lowentrystore/") ? "" : "lowentrystore/" + slice.name + "/") + STRING(reducerName));
+        actions[STRING(reducerName)] = reducerAction;
+        LeUtils.each(LeUtils.flattenArray(reducer), (innerReducer) => {
+          if (LeUtils.isGeneratorFunction(innerReducer)) {
+            const sagaListener = function* () {
+              yield ReduxSagaEffects.takeEvery(reducerAction, function* (action) {
+                let promiseResolve = null;
+                let promiseReject = null;
+                try {
+                  const typedAction = action;
+                  if (typedAction.__lowentry_dispatch__ === true) {
+                    const promise = new Promise((resolve, reject) => {
+                      promiseResolve = resolve;
+                      promiseReject = reject;
+                    });
+                    if (Array.isArray(typedAction.__lowentry_dispatch_result__)) {
+                      if (typeof promise !== "undefined") {
+                        typedAction.__lowentry_dispatch_result__.push(promise);
+                      }
+                    } else {
+                      typedAction.__lowentry_dispatch_result__ = promise;
+                    }
+                  }
+                  const result = yield innerReducer.apply(slice, [slice.state, typedAction.payload, typedAction]);
+                  if (promiseResolve !== null) {
+                    promiseResolve(result);
+                  }
+                } catch (e) {
+                  console.error('an error was thrown by your LeRed.createSlice(...) code, by slice "' + slice.name + '", action "' + STRING(reducerName) + '":');
+                  console.error(e);
+                  if (promiseReject !== null) {
+                    try {
+                      promiseReject(e);
+                    } catch (e2) {
+                      console.error(e2);
+                    }
+                  }
+                }
+              });
+            };
+            if (IS_ARRAY(sagas[STRING(reducerName)])) {
+              sagas[STRING(reducerName)].push(innerReducer);
+            } else {
+              sagas[STRING(reducerName)] = [innerReducer];
+            }
+            if (IS_ARRAY(sagaListeners[STRING(reducerName)])) {
+              sagaListeners[STRING(reducerName)].push(sagaListener);
+            } else {
+              sagaListeners[STRING(reducerName)] = [sagaListener];
+            }
+          } else {
+            const reducerFunction = (state, action) => {
+              try {
+                const typedAction = action;
+                if (typeof innerReducer === "function") {
+                  const result = innerReducer.apply(state, [state[slice.name], typedAction.payload]);
+                  if (typedAction.__lowentry_dispatch__ === true) {
+                    if (Array.isArray(typedAction.__lowentry_dispatch_result__)) {
+                      if (typeof result !== "undefined") {
+                        typedAction.__lowentry_dispatch_result__.push(result);
+                      }
+                    } else {
+                      typedAction.__lowentry_dispatch_result__ = result;
+                    }
+                  }
+                }
+              } catch (e) {
+                console.error('an error was thrown by your LeRed.createSlice(...) code, by slice "' + slice.name + '", action "' + STRING(reducerName) + '":');
+                console.error(e);
+              }
+            };
+            if (ISSET(reducers[STRING(reducerName)])) {
+              reducers[STRING(reducerName)].push(reducerFunction);
+            } else {
+              reducers[STRING(reducerName)] = [reducerFunction];
+            }
+          }
+        });
+      });
+    });
+    slice.actions = actions;
+    slice.reducers = reducers;
+    slice.sagas = sagas;
+    slice.sagaListeners = sagaListeners;
+    const selectors = {};
+    LeUtils.each(slice.selectors, (selector, selectorName) => {
+      selectors[STRING(selectorName)] = (state) => {
+        try {
+          if (typeof selector === "function") {
+            return selector.apply(state, [state[slice.name]]);
+          }
+        } catch (e) {
+          console.error('an error was thrown by your LeRed.createSlice(...) code, by slice "' + slice.name + '", selector "' + STRING(selectorName) + '":');
+          console.error(e);
+          return void 0;
+        }
+      };
+    });
+    slice.selectors = selectors;
+    const getters = {};
+    LeUtils.each(slice.getters, (getter, getterName) => {
+      getters[STRING(getterName)] = (...params) => {
+        try {
+          if (typeof getter === "function") {
+            const selector = getter(...params);
+            return (state) => {
+              try {
+                if (typeof selector === "function") {
+                  return selector.apply(state, [state[slice.name]]);
+                }
+              } catch (e) {
+                console.error('an error was thrown by your LeRed.createSlice(...) code, by slice "' + slice.name + '", getter "' + STRING(getterName) + '":');
+                console.error(e);
+                return void 0;
+              }
+            };
+          }
+        } catch (e) {
+          console.error('an error was thrown by your LeRed.createSlice(...) code, by slice "' + slice.name + '", getter "' + STRING(getterName) + '":');
+          console.error(e);
+          return () => void 0;
+        }
+        return () => void 0;
+      };
+    });
+    slice.getters = getters;
+    return slice;
+  } else {
+    slice.__lowentry_unfinished_slice = true;
+    return slice;
+  }
+};
+var createFastSlice = (slice) => {
+  if (!slice) {
+    return {};
+  }
+  if (Array.isArray(slice)) {
+    const e = new Error("the given slice is an array (instead of an object)");
+    console.error("an error was thrown by your LeRed.createFastSlice(...) code:");
+    console.error(e);
+    throw e;
+  }
+  const actions = {};
+  LeUtils.each(slice.actions, (reducer, reducerName) => {
+    actions[STRING(reducerName)] = (...params) => {
+      if (typeof reducer === "function") {
+        return reducer.apply(slice, [slice.state, ...params]);
+      }
+      return void 0;
+    };
+  });
+  slice.actions = actions;
+  const selectors = {};
+  LeUtils.each(slice.selectors, (selector, selectorName) => {
+    selectors[STRING(selectorName)] = () => {
+      if (typeof selector === "function") {
+        return selector.apply(slice, [slice.state]);
+      }
+      return void 0;
+    };
+  });
+  slice.selectors = new Proxy(selectors, {
+    get: (target, key) => {
+      if (!(key in target)) {
+        return void 0;
+      }
+      const targetRecord = target;
+      const getter = targetRecord[key];
+      if (typeof getter === "function") {
+        return getter();
+      }
+      return void 0;
+    }
+  });
+  const getters = {};
+  LeUtils.each(slice.getters, (selector, selectorName) => {
+    getters[STRING(selectorName)] = (...params) => {
+      if (typeof selector === "function") {
+        return selector.apply(slice, [slice.state, ...params]);
+      }
+      return void 0;
+    };
+  });
+  slice.getters = getters;
+  return slice;
+};
+var leRedCreateAction = (id) => {
+  return RTK.createAction("lowentrystore/lowentryaction/" + id);
+};
+var leRedCreateSelector = (selectorsGenerator) => {
+  return function(stateOfSlice) {
+    const state = this;
+    const selectors = selectorsGenerator.apply(state, [stateOfSlice]);
+    const selectorArgs = [];
+    for (let i = 0; i < selectors.length - 1; i++) {
+      let selectorsEntry = selectors[i];
+      if (typeof selectorsEntry === "function") {
+        const selectorFunc = selectorsEntry;
+        selectorsEntry = selectorFunc.apply(state, [state]);
+      }
+      selectorArgs.push(selectorsEntry);
+    }
+    let finalSelector = selectors[selectors.length - 1];
+    if (typeof finalSelector === "function") {
+      const finalSelectorFunc = finalSelector;
+      finalSelector = finalSelectorFunc.apply(state, selectorArgs);
+    }
+    return finalSelector;
+  };
+};
+var leRedCreateCachedSelector = (selectorsGenerator, equalsComparator) => {
+  const validatedComparator = fixEqualsComparator(equalsComparator, "LeRed.createCachedSelector() was given an invalid comparator:");
+  let previousSelectorArgs = null;
+  let previousFinalSelectorResult = null;
+  return function(stateOfSlice) {
+    const state = this;
+    const selectors = selectorsGenerator.apply(state, [stateOfSlice]);
+    const selectorArgs = [];
+    for (let i = 0; i < selectors.length - 1; i++) {
+      let selectorsEntry = selectors[i];
+      if (typeof selectorsEntry === "function") {
+        const selectorFunc = selectorsEntry;
+        selectorsEntry = selectorFunc.apply(state, [state]);
+      }
+      selectorArgs.push(selectorsEntry);
+    }
+    let finalSelector = selectors[selectors.length - 1];
+    if (typeof finalSelector === "function") {
+      if (validatedComparator(previousSelectorArgs, selectorArgs) && previousFinalSelectorResult !== null) {
+        finalSelector = previousFinalSelectorResult;
+      } else {
+        const finalSelectorFunc = finalSelector;
+        const result = finalSelectorFunc.apply(state, selectorArgs);
+        finalSelector = result;
+        previousSelectorArgs = selectorArgs;
+        previousFinalSelectorResult = finalSelector;
+      }
+    }
+    return finalSelector;
+  };
+};
+var batch2 = ReactRedux.batch;
+var connect2 = ReactRedux.connect;
+var useSelector2 = leRedUseSelector;
+var useDispatch2 = ReactRedux.useDispatch;
+var useStore2 = ReactRedux.useStore;
+var shallowEqual2 = ReactRedux.shallowEqual;
+var eventChannel2 = ReduxSaga.eventChannel;
+var buffers2 = ReduxSaga.buffers;
+var detach2 = ReduxSaga.detach;
+var END2 = ReduxSaga.END;
+var isEnd2 = ReduxSaga.isEnd;
+var channel2 = ReduxSaga.channel;
+var multicastChannel2 = ReduxSaga.multicastChannel;
+var stdChannel2 = ReduxSaga.stdChannel;
+var runSaga2 = ReduxSaga.runSaga;
+var useConfigureStore = (storeData) => {
+  return leRedUseMemo(() => configureStore2(storeData), [storeData], LeUtils.equals);
+};
+var useEffectInterval = (callable, comparingValues, intervalMs, fireImmediately, equalsComparator) => {
+  const callableRef = React.useRef(callable);
+  callableRef.current = callable;
+  leRedUseEffect(() => LeUtils.setInterval(() => callableRef.current(), intervalMs, fireImmediately).remove, [comparingValues, intervalMs, fireImmediately, equalsComparator], LeUtils.equals);
+};
+var useEffectAnimationFrameInterval = (callable, comparingValues, intervalFrames, fireImmediately, equalsComparator) => {
+  const callableRef = React.useRef(callable);
+  callableRef.current = callable;
+  leRedUseEffect(() => LeUtils.setAnimationFrameInterval(() => callableRef.current(), intervalFrames, fireImmediately).remove, [comparingValues, intervalFrames, fireImmediately, equalsComparator], LeUtils.equals);
+};
+var useEffectGenerator = (callable, comparingValues, _intervalMs, _fireImmediately, equalsComparator) => {
+  const callableRef = React.useRef(callable);
+  callableRef.current = callable;
+  leRedUseEffect(() => {
+    let stop = false;
+    (async () => {
+      for (const promise of callableRef.current()) {
+        if (stop) {
+          return;
+        }
+        await promise;
+        if (stop) {
+          return;
+        }
+      }
+    })();
+    return () => {
+      stop = true;
+    };
+  }, [comparingValues, equalsComparator], LeUtils.equals);
+};
+var useEffectGeneratorLoop = (callable, comparingValues, _intervalMs, _fireImmediately, equalsComparator) => {
+  const callableRef = React.useRef(callable);
+  callableRef.current = callable;
+  leRedUseEffect(() => {
+    let stop = false;
+    (async () => {
+      while (!stop) {
+        for (const promise of callableRef.current()) {
+          if (stop) {
+            return;
+          }
+          await promise;
+          if (stop) {
+            return;
+          }
+        }
+      }
+    })();
+    return () => {
+      stop = true;
+    };
+  }, [comparingValues, equalsComparator], LeUtils.equals);
+};
+var useEffectShutdown = (callable, comparingValues, equalsComparator) => {
+  leRedUseEffect(() => {
+    const run = () => {
+      callable();
+    };
+    globalThis?.addEventListener?.("beforeunload", run, { capture: true });
+    return () => {
+      globalThis?.removeEventListener?.("beforeunload", run, { capture: true });
+      run();
+    };
+  }, [comparingValues, equalsComparator], LeUtils.equals);
+};
+var useEffectPageFocusLost = (callable, comparingValues, equalsComparator) => {
+  const events = ["pagehide", "freeze", "blur", "visibilitychange"];
+  leRedUseEffect(() => {
+    const run = () => {
+      if (globalThis?.document?.visibilityState !== "hidden" && globalThis?.document?.hasFocus?.()) {
+        return;
+      }
+      callable();
+    };
+    events.forEach((type) => {
+      globalThis?.addEventListener?.(type, run, { capture: true });
+    });
+    return () => {
+      events.forEach((type) => {
+        globalThis?.removeEventListener?.(type, run, { capture: true });
+      });
+    };
+  }, [comparingValues, equalsComparator], LeUtils.equals);
+};
+var usePrevious = (value, initialValue) => {
+  const ref = React.useRef(initialValue);
+  leRedUseEffect(() => {
+    ref.current = value;
+  }, [value], LeUtils.equals);
+  return ref.current;
+};
+var useFont = (font) => {
+  const fontStr = "12px " + STRING(font).trim();
+  const [hasFont, setHasFont] = React.useState(false);
+  leRedUseEffect(() => {
+    if (!hasFont) {
+      if (!globalThis?.document?.fonts?.check) {
+        setHasFont(true);
+        return;
+      }
+      const handler = setInterval(() => {
+        try {
+          if (globalThis.document.fonts.check(fontStr)) {
+            clearInterval(handler);
+            setHasFont(true);
+          }
+        } catch (e) {
+          console.error(e);
+          clearInterval(handler);
+          setHasFont(true);
+        }
+      }, 30);
+    }
+  }, [hasFont], LeUtils.equals);
+  return hasFont;
+};
+var useScript = (url, props = {}) => {
+  leRedUseEffect(() => {
+    if (!globalThis?.document?.createElement || !globalThis?.document?.head?.appendChild || !globalThis?.document?.head?.removeChild) {
+      return;
+    }
+    const script = globalThis.document.createElement("script");
+    script.type = "text/javascript";
+    script.src = url;
+    LeUtils.each(props, (value, key) => {
+      script.setAttribute(STRING(key), STRING(value));
+    });
+    globalThis.document.head.appendChild(script);
+    return () => globalThis.document.head.removeChild(script);
+  }, [url, props], LeUtils.equals);
+};
+var mergeRefs = (...refs) => {
+  const flattenedRefs = LeUtils.flattenArray(refs);
+  if (!flattenedRefs) {
+    return null;
+  }
+  const newRefs = [];
+  LeUtils.each(flattenedRefs, (ref) => {
+    const isReactRef = (r) => {
+      return typeof r === "function" || !!r && typeof r === "object" && "current" in r || r === null;
+    };
+    if (isReactRef(ref) && ref !== null) {
+      newRefs.push(ref);
+    }
+  });
+  if (newRefs.length <= 0) {
+    return null;
+  }
+  const isMutableRefObject = (r) => {
+    return !!r && typeof r === "object" && "current" in r;
+  };
+  if (newRefs.length === 1) {
+    const singleRef = newRefs[0];
+    if (typeof singleRef === "function") {
+      return singleRef;
+    }
+    return (inst) => {
+      if (isMutableRefObject(singleRef)) {
+        singleRef.current = inst;
+      }
+    };
+  }
+  return (inst) => {
+    LeUtils.each(newRefs, (ref) => {
+      if (!ref) {
+        return;
+      }
+      try {
+        const isCallbackRef = (r) => {
+          return typeof r === "function";
+        };
+        if (isCallbackRef(ref)) {
+          ref(inst);
+        } else if (isMutableRefObject(ref)) {
+          ref.current = inst;
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    });
+  };
+};
+var useTriggerable = (event) => {
+  const [[value], setValue] = React.useState([null, LeUtils.uniqueId()]);
+  leRedUseEffect(() => {
+    const globalObj = globalThis;
+    if (!globalObj.addEventListener || !globalObj.removeEventListener) {
+      return;
+    }
+    const callback = (e) => {
+      const isCustomEvent = (event2) => {
+        return "detail" in event2;
+      };
+      if (isCustomEvent(e)) {
+        setValue([e.detail, LeUtils.uniqueId()]);
+      }
+    };
+    const eventName = "lowentrytriggerable_" + event;
+    globalThis.addEventListener(eventName, callback);
+    return () => globalThis.removeEventListener(eventName, callback);
+  }, [event], LeUtils.equals);
+  return value;
+};
+var trigger = (event, value) => {
+  if (!globalThis?.dispatchEvent || typeof CustomEvent !== "function") {
+    return;
+  }
+  const eventName = "lowentrytriggerable_" + event;
+  globalThis.dispatchEvent(new CustomEvent(eventName, { detail: value }));
+};
+var useTempState = (defaultValue, duration) => {
+  const [value, setValue] = React.useState(defaultValue);
+  const timeoutHandle = React.useRef(null);
+  const defaultValueRef = React.useRef(defaultValue);
+  defaultValueRef.current = defaultValue;
+  const durationRef = React.useRef(duration);
+  durationRef.current = duration;
+  leRedUseEffect(() => {
+    return () => {
+      if (timeoutHandle.current) {
+        clearTimeout(timeoutHandle.current);
+      }
+    };
+  }, [], LeUtils.equals);
+  return [value, (newValue) => {
+    if (timeoutHandle.current) {
+      clearTimeout(timeoutHandle.current);
+    }
+    setValue(newValue);
+    timeoutHandle.current = setTimeout(() => {
+      timeoutHandle.current = null;
+      setValue(defaultValueRef.current);
+    }, durationRef.current);
+  }];
+};
+var historyStateListeners = [];
+if (typeof globalThis !== "undefined") {
+  globalThis?.addEventListener?.("popstate", () => {
+    historyStateListeners.pop()?.callback();
+  });
+}
+var addHistoryListener = (callback) => {
+  const id = LeUtils.uniqueId();
+  historyStateListeners.push({ id, callback });
+  return id;
+};
+var removeHistoryListener = (id) => {
+  if (!id) {
+    return;
+  }
+  historyStateListeners = historyStateListeners.filter((listener) => listener.id !== id);
+};
+var useHistory = (onForward, onBack) => {
+  const remaining = React.useRef(0);
+  const id = React.useRef(null);
+  const onForwardRef = React.useRef(onForward);
+  onForwardRef.current = onForward;
+  const onBackRef = React.useRef(onBack);
+  onBackRef.current = onBack;
+  const goBack = leRedUseCallback(() => {
+    if (remaining.current <= 0) {
+      return;
+    }
+    remaining.current--;
+    if (remaining.current === 0) {
+      if (id.current) {
+        removeHistoryListener(id.current);
+      }
+      id.current = null;
+    }
+    onBackRef.current();
+  }, [], LeUtils.equals);
+  leRedUseEffect(() => {
+    return () => {
+      if (id.current) {
+        removeHistoryListener(id.current);
+      }
+    };
+  }, [], LeUtils.equals);
+  return [
+    () => {
+      if (typeof window !== "undefined" && window.history) {
+        window.history.pushState(null, "", window.location.pathname + window.location.search + "#");
+      }
+      remaining.current++;
+      if (remaining.current === 1) {
+        if (id.current) {
+          removeHistoryListener(id.current);
+        }
+        id.current = addHistoryListener(goBack);
+      }
+      onForwardRef.current();
+    },
+    () => {
+      if (remaining.current > 0) {
+        if (typeof window !== "undefined" && window.history) {
+          window.history.back();
+        }
+      }
+    }
+  ];
+};
+var useHistoryState = (initialState) => {
+  const [state, setState] = React.useState(!!initialState);
+  const [forwards, backwards] = useHistory(() => setState(!initialState), () => setState(!!initialState));
+  if (initialState) {
+    return [state, backwards, forwards];
+  }
+  return [state, forwards, backwards];
+};
+var useUrlHashParams = () => {
+  const getHashString = () => globalThis?.location?.hash?.trim()?.replace(/^#/, "") ?? "";
+  const parseHashParams = (hashString2) => Object.fromEntries(new URLSearchParams(hashString2));
+  const [hashString, setHashString] = React.useState(getHashString);
+  const hashParams = leRedUseMemo(() => parseHashParams(hashString), [hashString], LeUtils.equals);
+  leRedUseEffect(() => {
+    const onUrlChanged = () => {
+      setHashString(getHashString());
+    };
+    globalThis?.addEventListener?.("hashchange", onUrlChanged);
+    return () => {
+      globalThis?.removeEventListener?.("hashchange", onUrlChanged);
+    };
+  }, [], LeUtils.equals);
+  return [hashParams, hashString];
+};
+var useRetryingImageUrl = (url, options) => {
+  const normalizedUrl = STRING(url);
+  const urlHasQ = normalizedUrl.includes("?");
+  const [imageUrl, setImageUrl] = React.useState(normalizedUrl);
+  const retries = React.useRef(0);
+  const timeout = React.useRef({ remove: () => void 0 });
+  leRedUseEffect(() => {
+    return () => timeout.current.remove();
+  }, [], LeUtils.equals);
+  leRedUseEffect(() => {
+    timeout.current.remove();
+    retries.current = 0;
+    setImageUrl(normalizedUrl);
+  }, [normalizedUrl], LeUtils.equals);
+  const onImageLoadError = leRedUseCallback(() => {
+    if (retries.current < INT_LAX_ANY(options?.retries, 30)) {
+      const defaultDelay = 100 + 50 * retries.current;
+      timeout.current.remove();
+      timeout.current = LeUtils.setTimeout(() => {
+        setImageUrl(normalizedUrl + (urlHasQ ? "&" : "?") + (options?.queryParam || "lowentryretryingimgversion") + "=" + retries.current++);
+      }, typeof options?.delay === "function" ? INT_LAX_ANY(options?.delay(retries.current), defaultDelay) : INT_LAX_ANY(options?.delay, defaultDelay));
+    }
+  }, [normalizedUrl, options, urlHasQ], LeUtils.equals);
+  const onImageLoadErrorIgnored = leRedUseCallback(() => {
+  }, [], LeUtils.equals);
+  if (!normalizedUrl) {
+    return [normalizedUrl, onImageLoadErrorIgnored];
+  }
+  return [imageUrl, onImageLoadError];
+};
+var usePromises = (callable, comparingValues) => {
+  const comparingValuesClone = LeUtils.clone(comparingValues);
+  const comparingValuesRef = React.useRef(comparingValuesClone);
+  const latestComparingValuesRef = React.useRef(null);
+  latestComparingValuesRef.current = comparingValuesClone;
+  const callableRef = React.useRef(callable);
+  callableRef.current = callable;
+  const [data, setData] = React.useState(null);
+  const [loading, setLoading] = React.useState(true);
+  const [error, setError] = React.useState(null);
+  leRedUseEffect(() => {
+    setLoading(true);
+    setData(null);
+    setError(null);
+    try {
+      const promises = callableRef.current();
+      let promisesIsObject = false;
+      if (IS_OBJECT(promises)) {
+        if ("then" in promises && typeof promises.then === "function") {
+          promisesIsObject = false;
+        } else {
+          promisesIsObject = true;
+        }
+      }
+      const promisesIsArray = IS_ARRAY(promises);
+      const promisesKeyed = [];
+      if (promisesIsObject || promisesIsArray) {
+        LeUtils.each(promises, (promise, key) => {
+          if (promise && typeof promise === "object" && "then" in promise && typeof promise.then === "function") {
+            promisesKeyed.push({ promise, key });
+          }
+        });
+      } else {
+        if (promises && typeof promises === "object" && "then" in promises && typeof promises.then === "function") {
+          promisesKeyed.push({ promise: promises, key: void 0 });
+        }
+      }
+      const wrappedPromises = [];
+      LeUtils.each(promisesKeyed, (item) => {
+        if (item && typeof item === "object" && "promise" in item && "key" in item) {
+          const typedItem = item;
+          wrappedPromises.push(typedItem.promise.then(async (result) => ({ result, key: typedItem.key })));
+        }
+      });
+      Promise.all(wrappedPromises).then((resultObjects) => {
+        if (promisesIsObject) {
+          const results = {};
+          LeUtils.each(resultObjects, (item) => {
+            if (item && typeof item === "object" && "result" in item && "key" in item) {
+              const typedItem = item;
+              results[STRING(typedItem.key)] = typedItem.result;
+            }
+          });
+          return results;
+        } else if (promisesIsArray) {
+          const results = [];
+          LeUtils.each(resultObjects, (item) => {
+            if (item && typeof item === "object" && "result" in item && "key" in item) {
+              const typedItem = item;
+              const keyNum = typeof typedItem.key === "number" ? typedItem.key : 0;
+              results[keyNum] = typedItem.result;
+            }
+          });
+          return results;
+        }
+        const lastResult = resultObjects.pop();
+        return lastResult?.result ?? null;
+      }).then((results) => {
+        if (!LeUtils.equals(latestComparingValuesRef.current, comparingValuesClone)) {
+          return;
+        }
+        comparingValuesRef.current = comparingValuesClone;
+        setLoading(false);
+        setData(results);
+        setError(null);
+      }).catch((errorObj) => {
+        if (!LeUtils.equals(latestComparingValuesRef.current, comparingValuesClone)) {
+          return;
+        }
+        comparingValuesRef.current = comparingValuesClone;
+        setLoading(false);
+        setData(null);
+        setError(LeUtils.purgeErrorMessage(errorObj));
+      });
+      return () => {
+        LeUtils.each(wrappedPromises, (promise) => {
+          try {
+            if (promise && typeof promise === "object" && "cancel" in promise && typeof promise.cancel === "function") {
+              promise.cancel();
+            }
+          } catch (e) {
+            console.error("Failed to cancel the given promise:", e);
+          }
+        });
+      };
+    } catch (errorObj) {
+      LeUtils.setAnimationFrameTimeout(() => {
+        if (!LeUtils.equals(latestComparingValuesRef.current, comparingValuesClone)) {
+          return;
+        }
+        comparingValuesRef.current = comparingValuesClone;
+        setLoading(false);
+        setData(null);
+        setError(LeUtils.purgeErrorMessage(errorObj));
+      }, 1);
+    }
+  }, [comparingValuesClone], LeUtils.equals);
+  if (!LeUtils.equals(comparingValuesRef.current, comparingValuesClone)) {
+    return [null, true, null];
+  }
+  return [data, loading, error];
+};
+var useExternal = (url, options, responseFunction) => {
+  return usePromises(() => {
+    const createFetch = (urlString) => {
+      const fetchResult = LeUtils.fetch(STRING(urlString), { retries: 3, ...options ?? {} });
+      return new Promise((resolve, reject) => {
+        if (fetchResult && typeof fetchResult === "object" && "then" in fetchResult && typeof fetchResult.then === "function") {
+          fetchResult.then(async (response) => {
+            const data = await responseFunction(response);
+            if (typeof options?.verify === "function") {
+              await options.verify(data, response);
+            }
+            resolve(data);
+          }, reject);
+        } else {
+          reject(new Error("LeUtils.fetch did not return a promise-like object"));
+        }
+      });
+    };
+    if (IS_OBJECT(url)) {
+      const promises = {};
+      LeUtils.each(url, (urlString, key) => {
+        promises[STRING(key)] = createFetch(urlString);
+      });
+      return promises;
+    }
+    if (IS_ARRAY(url)) {
+      const promises = [];
+      LeUtils.each(url, (urlString) => {
+        promises.push(createFetch(urlString));
+      });
+      return promises;
+    }
+    return createFetch(url);
+  }, [url, options, responseFunction]);
+};
+var useExternalJson = (url, options) => {
+  const responseFunction = leRedUseCallback((response) => response.json(), [], LeUtils.equals);
+  return useExternal(url, options, responseFunction);
+};
+var useExternalBlob = (url, options) => {
+  const responseFunction = leRedUseCallback((response) => response.blob(), [], LeUtils.equals);
+  return useExternal(url, options, responseFunction);
+};
+var useExternalArrayBuffer = (url, options) => {
+  const responseFunction = leRedUseCallback((response) => response.arrayBuffer(), [], LeUtils.equals);
+  return useExternal(url, options, responseFunction);
+};
+var useExternalString = (url, options) => {
+  const responseFunction = leRedUseCallback((response) => response.text(), [], LeUtils.equals);
+  return useExternal(url, options, responseFunction);
+};
+var useExternalFormData = (url, options) => {
+  const responseFunction = leRedUseCallback((response) => response.formData(), [], LeUtils.equals);
+  return useExternal(url, options, responseFunction);
+};
+var delayFrames = function* (frames = 1) {
+  yield ReduxSagaEffects.call(() => {
+    return new Promise((resolve, reject) => {
+      try {
+        LeUtils.setAnimationFrameTimeout(() => resolve(), frames);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+};
+var interval = function* (callback, intervalMs) {
+  let channelVar = eventChannel2((emitter) => {
+    const intervalHandle = setInterval(() => {
+      emitter({});
+    }, intervalMs);
+    return () => {
+      clearInterval(intervalHandle);
+    };
+  });
+  const stop = () => {
+    try {
+      if (channelVar !== null) {
+        channelVar.close();
+        channelVar = null;
+      }
+    } catch (e) {
+      console.error(e);
+    }
+  };
+  while (channelVar !== null) {
+    try {
+      yield ReduxSagaEffects.take(channelVar);
+      yield callback(stop);
+    } catch (e) {
+      console.error(e);
+    } finally {
+      try {
+        if (yield ReduxSagaEffects.cancelled()) {
+          channelVar.close();
+          channelVar = null;
+        }
+      } catch (e) {
+        console.error(e);
+      }
+    }
+  }
+};
+var effects = {
+  ...ReduxSagaEffects,
+  delayFrames,
+  interval
+};
+var Root = memo2(({ store, children, ...other }) => {
+  if (ISSET(store)) {
+    const configuredStore = configureStore2(store);
+    return /* @__PURE__ */ jsx(ReactRedux.Provider, { store: configuredStore, children, ...other });
+  }
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}, LeUtils.equals);
+var PreloadComponent = (load) => {
+  if (typeof window !== "undefined") {
+    const promise = load();
+    return () => promise;
+  }
+  return load;
+};
+var LoadComponent = memo2(({ loading, load, ...other }) => {
+  const [Component, setComponent] = React.useState(loading ?? null);
+  leRedUseEffect(() => {
+    (async () => {
+      const LoadedComponent = typeof load === "function" ? await load() : await load;
+      if (!LoadedComponent) {
+        setComponent(null);
+        return;
+      }
+      setComponent(/* @__PURE__ */ jsx(LoadedComponent, { ...other }));
+    })();
+  }, [], LeUtils.equals);
+  return Component;
+}, LeUtils.equals);
+var LeRedBase = {
+  // React Hooks
+  useState: useState2,
+  useEffect: useEffect2,
+  useLayoutEffect: useLayoutEffect2,
+  useContext: useContext2,
+  useReducer: useReducer2,
+  useCallback: useCallback2,
+  useMemo: useMemo2,
+  useRef: useRef2,
+  useImperativeHandle: useImperativeHandle2,
+  useDebugValue: useDebugValue2,
+  useDeferredValue: useDeferredValue2,
+  useTransition: useTransition2,
+  useSyncExternalStore: useSyncExternalStore2,
+  useId: useId2,
+  useInsertionEffect: useInsertionEffect2,
+  // React Utils
+  createContext: createContext2,
+  createElement: createElement2,
+  cloneElement: cloneElement2,
+  isValidElement: isValidElement2,
+  lazy: lazy2,
+  forwardRef: forwardRef2,
+  memo: memo2,
+  startTransition: startTransition2,
+  // ReactDOM
+  createPortal: createPortal2,
+  flushSync: flushSync2,
+  // Redux / RTK
+  combineReducers: combineReducers2,
+  applyMiddleware: applyMiddleware2,
+  compose: compose2,
+  bindActionCreators: bindActionCreators2,
+  configureStore: configureStore2,
+  createSlice: createSlice2,
+  createFastSlice,
+  createAction: leRedCreateAction,
+  createReducer: createReducer2,
+  createAsyncThunk: createAsyncThunk2,
+  createEntityAdapter: createEntityAdapter2,
+  createSelector: leRedCreateSelector,
+  createCachedSelector: leRedCreateCachedSelector,
+  createNextState: createNextState2,
+  produce,
+  freeze: freeze2,
+  isDraft: isDraft2,
+  original: original2,
+  combineSlices: combineSlices2,
+  createListenerMiddleware: createListenerMiddleware2,
+  createDynamicMiddleware: createDynamicMiddleware2,
+  autoBatchEnhancer: autoBatchEnhancer2,
+  isAnyOf: isAnyOf2,
+  isAllOf: isAllOf2,
+  isPending: isPending2,
+  isFulfilled: isFulfilled2,
+  isRejected: isRejected2,
+  isAsyncThunkAction: isAsyncThunkAction2,
+  isRejectedWithValue: isRejectedWithValue2,
+  nanoid: nanoid2,
+  current: current2,
+  isImmutableDefault: isImmutableDefault2,
+  unwrapResult: unwrapResult2,
+  // React-Redux
+  useSelector: useSelector2,
+  useDispatch: useDispatch2,
+  useStore: useStore2,
+  shallowEqual: shallowEqual2,
+  batch: batch2,
+  connect: connect2,
+  // Redux-Saga
+  eventChannel: eventChannel2,
+  buffers: buffers2,
+  detach: detach2,
+  channel: channel2,
+  multicastChannel: multicastChannel2,
+  stdChannel: stdChannel2,
+  runSaga: runSaga2,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  END: END2,
+  isEnd: isEnd2,
+  effects,
+  // Custom Hooks
+  useConfigureStore,
+  useEffectInterval,
+  useEffectAnimationFrameInterval,
+  useEffectGenerator,
+  useEffectGeneratorLoop,
+  useEffectShutdown,
+  useEffectPageFocusLost,
+  usePrevious,
+  useFont,
+  useScript,
+  mergeRefs,
+  useTriggerable,
+  trigger,
+  useTempState,
+  useHistory,
+  useHistoryState,
+  useUrlHashParams,
+  useRetryingImageUrl,
+  usePromises,
+  useExternal,
+  useExternalJson,
+  useExternalBlob,
+  useExternalArrayBuffer,
+  useExternalString,
+  useExternalFormData,
+  // Components (React components use PascalCase by convention)
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  Root,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  LoadComponent,
+  // eslint-disable-next-line @typescript-eslint/naming-convention
+  PreloadComponent
+};
+var LeRedProxy = new Proxy(LeRedBase, {
+  get: (target, prop) => {
+    if (typeof prop === "string" && !(prop in target)) {
+      if (prop === "set" || prop === "setAll") {
+        console.error(`LeRed.${prop} is no longer supported in current version.`);
+        return void 0;
+      }
+      if (prop === "register" || prop === "navigate" || prop === "graphql") {
+        console.error(`LeRed.${prop} is no longer available. For Gatsby, import from 'gatsby' directly. For Firebase, use the '@lowentry/firebase' package with {LeFirebase}.`);
+        return void 0;
+      }
+      if (prop.startsWith("firebase") || prop.startsWith("useAuth") || prop.startsWith("useDoc") || prop.startsWith("useList") || prop.startsWith("useObject") || prop === "setDocument" || prop === "updateDocument" || prop === "deleteDocument" || prop === "addDocument" || prop === "signOut" || prop === "signIn" || prop === "sendPassword" || prop === "createUser" || prop === "fetchSign" || prop === "trace" || prop === "getPerformance" || prop === "initializeFirestore" || prop === "getDatabase" || prop === "getAuth" || prop === "getAnalytics") {
+        console.error(`LeRed.${prop} is no longer available. Please use {LeFirebase} from '@lowentry/firebase' instead.`);
+        return void 0;
+      }
+      const firstChar = prop.charAt(0);
+      if (firstChar === firstChar.toUpperCase() && firstChar !== firstChar.toLowerCase()) {
+        console.error(`LeRed.${prop} is not available on the LeRed object. Please use the original library (like React or MUI) instead.`);
+        return void 0;
+      } else {
+        console.warn(`LeRed.${prop} is not available. Please use the original library (like React or Redux) instead.`);
+        return void 0;
+      }
+    }
+    if (typeof prop === "symbol") {
+      return target[prop];
+    }
+    return target[prop];
+  }
+});
+var LeRed = LeRedProxy;
+export {
+  Children2 as Children,
+  END2 as END,
+  LeRed,
+  LoadComponent,
+  PreloadComponent,
+  Root,
+  applyMiddleware2 as applyMiddleware,
+  autoBatchEnhancer2 as autoBatchEnhancer,
+  batch2 as batch,
+  bindActionCreators2 as bindActionCreators,
+  buffers2 as buffers,
+  channel2 as channel,
+  cloneElement2 as cloneElement,
+  combineReducers2 as combineReducers,
+  combineSlices2 as combineSlices,
+  compose2 as compose,
+  configureStore2 as configureStore,
+  connect2 as connect,
+  createAsyncThunk2 as createAsyncThunk,
+  createContext2 as createContext,
+  createDynamicMiddleware2 as createDynamicMiddleware,
+  createElement2 as createElement,
+  createEntityAdapter2 as createEntityAdapter,
+  createFastSlice,
+  createListenerMiddleware2 as createListenerMiddleware,
+  createNextState2 as createNextState,
+  createPortal2 as createPortal,
+  createReducer2 as createReducer,
+  createSlice2 as createSlice,
+  current2 as current,
+  delayFrames,
+  detach2 as detach,
+  effects,
+  eventChannel2 as eventChannel,
+  flushSync2 as flushSync,
+  forwardRef2 as forwardRef,
+  freeze2 as freeze,
+  interval,
+  isAllOf2 as isAllOf,
+  isAnyOf2 as isAnyOf,
+  isAsyncThunkAction2 as isAsyncThunkAction,
+  isDraft2 as isDraft,
+  isEnd2 as isEnd,
+  isFulfilled2 as isFulfilled,
+  isImmutableDefault2 as isImmutableDefault,
+  isPending2 as isPending,
+  isRejected2 as isRejected,
+  isRejectedWithValue2 as isRejectedWithValue,
+  isValidElement2 as isValidElement,
+  lazy2 as lazy,
+  leRedCreateAction,
+  leRedCreateCachedSelector,
+  leRedCreateSelector,
+  leRedMemo,
+  leRedUseCallback,
+  leRedUseEffect,
+  leRedUseLayoutEffect,
+  leRedUseMemo,
+  leRedUseSelector,
+  memo2 as memo,
+  mergeRefs,
+  multicastChannel2 as multicastChannel,
+  nanoid2 as nanoid,
+  original2 as original,
+  produce,
+  runSaga2 as runSaga,
+  shallowEqual2 as shallowEqual,
+  startTransition2 as startTransition,
+  stdChannel2 as stdChannel,
+  trigger,
+  unwrapResult2 as unwrapResult,
+  useCallback2 as useCallback,
+  useConfigureStore,
+  useContext2 as useContext,
+  useDebugValue2 as useDebugValue,
+  useDeferredValue2 as useDeferredValue,
+  useDispatch2 as useDispatch,
+  useEffect2 as useEffect,
+  useEffectAnimationFrameInterval,
+  useEffectGenerator,
+  useEffectGeneratorLoop,
+  useEffectInterval,
+  useEffectPageFocusLost,
+  useEffectShutdown,
+  useExternal,
+  useExternalArrayBuffer,
+  useExternalBlob,
+  useExternalFormData,
+  useExternalJson,
+  useExternalString,
+  useFont,
+  useHistory,
+  useHistoryState,
+  useId2 as useId,
+  useImperativeHandle2 as useImperativeHandle,
+  useInsertionEffect2 as useInsertionEffect,
+  useLayoutEffect2 as useLayoutEffect,
+  useMemo2 as useMemo,
+  usePrevious,
+  usePromises,
+  useReducer2 as useReducer,
+  useRef2 as useRef,
+  useRetryingImageUrl,
+  useScript,
+  useSelector2 as useSelector,
+  useState2 as useState,
+  useStore2 as useStore,
+  useSyncExternalStore2 as useSyncExternalStore,
+  useTempState,
+  useTransition2 as useTransition,
+  useTriggerable,
+  useUrlHashParams
+};
+//# sourceMappingURL=index.js.map