@hairy/react-lib 1.47.0 → 1.50.0

package/dist/index.global.js

@@ -1,1550 +0,0 @@
-"use strict";
-var LibReact = (() => {
-  var __create = Object.create;
-  var __defProp = Object.defineProperty;
-  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-  var __getOwnPropNames = Object.getOwnPropertyNames;
-  var __getProtoOf = Object.getPrototypeOf;
-  var __hasOwnProp = Object.prototype.hasOwnProperty;
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
-  var __export = (target, all) => {
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-  var __copyProps = (to, from, except, desc) => {
-    if (from && typeof from === "object" || typeof from === "function") {
-      for (let key of __getOwnPropNames(from))
-        if (!__hasOwnProp.call(to, key) && key !== except)
-          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-    }
-    return to;
-  };
-  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-    // If the importer is in node compatibility mode or this is not an ESM
-    // file that has been converted to a CommonJS file using a Babel-
-    // compatible transform (i.e. "__esModule" has not been set), then set
-    // "default" to the CommonJS "module.exports" for node compatibility.
-    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-    mod
-  ));
-  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-  // globals:react
-  var require_react = __commonJS({
-    "globals:react"(exports, module) {
-      "use strict";
-      module.exports = React;
-    }
-  });
-
-  // src/index.ts
-  var index_exports = {};
-  __export(index_exports, {
-    Case: () => Case,
-    Default: () => Default,
-    Else: () => Else,
-    If: () => If,
-    Injector: () => Injector,
-    Switch: () => Switch,
-    Then: () => Then,
-    Trigger: () => Trigger,
-    Unless: () => Unless,
-    cls: () => cls,
-    defienAsyncStore: () => defienAsyncStore,
-    defineStore: () => defineStore,
-    defineStoreAsync: () => defineStoreAsync,
-    proxyWithPersistant: () => proxyWithPersistant,
-    track: () => track,
-    tryUseCallback: () => tryUseCallback,
-    tryUseEffect: () => tryUseEffect,
-    tryUseInsertionEffect: () => tryUseInsertionEffect,
-    tryUseReducer: () => tryUseReducer,
-    tryUseRef: () => tryUseRef,
-    tryUseState: () => tryUseState,
-    tryUseUpdate: () => tryUseUpdate,
-    useAsyncCallback: () => useAsyncCallback,
-    useAsyncState: () => useAsyncState,
-    useDebounce: () => useDebounce,
-    useEventBus: () => useEventBus,
-    useFetchRequestIntercept: () => useFetchRequestIntercept,
-    useFetchResponseIntercept: () => useFetchResponseIntercept,
-    useMounted: () => useMounted,
-    useOffsetPagination: () => useOffsetPagination,
-    useStatus: () => useStatus,
-    useStore: () => useStore,
-    useUpdate: () => useUpdate,
-    useWatch: () => useWatch,
-    useWhenever: () => useWhenever,
-    wrapper: () => wrapper
-  });
-
-  // src/utils/cls.ts
-  var hasOwn = {}.hasOwnProperty;
-  function cls(...args) {
-    let classes = "";
-    for (let i = 0; i < args.length; i++) {
-      const arg = args[i];
-      if (arg)
-        classes = cls.append(classes, cls.parse(arg));
-    }
-    return classes;
-  }
-  cls.parse = function(arg) {
-    if (typeof arg === "string")
-      return arg;
-    if (typeof arg !== "object")
-      return "";
-    if (Array.isArray(arg))
-      return cls.apply(null, arg);
-    if (arg.toString !== Object.prototype.toString && !arg.toString.toString().includes("[native code]"))
-      return cls.toString();
-    let classes = "";
-    for (const key in arg) {
-      if (hasOwn.call(arg, key) && arg[key])
-        classes = cls.append(classes, key);
-    }
-    return classes;
-  };
-  cls.append = function(value, newClass) {
-    if (!newClass)
-      return value;
-    return value ? `${value} ${newClass}` : newClass;
-  };
-
-  // ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_freeGlobal.js
-  var freeGlobal = typeof global == "object" && global && global.Object === Object && global;
-  var freeGlobal_default = freeGlobal;
-
-  // ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_root.js
-  var freeSelf = typeof self == "object" && self && self.Object === Object && self;
-  var root = freeGlobal_default || freeSelf || Function("return this")();
-  var root_default = root;
-
-  // ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_Symbol.js
-  var Symbol2 = root_default.Symbol;
-  var Symbol_default = Symbol2;
-
-  // ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_getRawTag.js
-  var objectProto = Object.prototype;
-  var hasOwnProperty = objectProto.hasOwnProperty;
-  var nativeObjectToString = objectProto.toString;
-  var symToStringTag = Symbol_default ? Symbol_default.toStringTag : void 0;
-  function getRawTag(value) {
-    var isOwn = hasOwnProperty.call(value, symToStringTag), tag = value[symToStringTag];
-    try {
-      value[symToStringTag] = void 0;
-      var unmasked = true;
-    } catch (e) {
-    }
-    var result = nativeObjectToString.call(value);
-    if (unmasked) {
-      if (isOwn) {
-        value[symToStringTag] = tag;
-      } else {
-        delete value[symToStringTag];
-      }
-    }
-    return result;
-  }
-  var getRawTag_default = getRawTag;
-
-  // ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_objectToString.js
-  var objectProto2 = Object.prototype;
-  var nativeObjectToString2 = objectProto2.toString;
-  function objectToString(value) {
-    return nativeObjectToString2.call(value);
-  }
-  var objectToString_default = objectToString;
-
-  // ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/_baseGetTag.js
-  var nullTag = "[object Null]";
-  var undefinedTag = "[object Undefined]";
-  var symToStringTag2 = Symbol_default ? Symbol_default.toStringTag : void 0;
-  function baseGetTag(value) {
-    if (value == null) {
-      return value === void 0 ? undefinedTag : nullTag;
-    }
-    return symToStringTag2 && symToStringTag2 in Object(value) ? getRawTag_default(value) : objectToString_default(value);
-  }
-  var baseGetTag_default = baseGetTag;
-
-  // ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isObject.js
-  function isObject(value) {
-    var type = typeof value;
-    return value != null && (type == "object" || type == "function");
-  }
-  var isObject_default = isObject;
-
-  // ../../node_modules/.pnpm/lodash-es@4.17.21/node_modules/lodash-es/isFunction.js
-  var asyncTag = "[object AsyncFunction]";
-  var funcTag = "[object Function]";
-  var genTag = "[object GeneratorFunction]";
-  var proxyTag = "[object Proxy]";
-  function isFunction(value) {
-    if (!isObject_default(value)) {
-      return false;
-    }
-    var tag = baseGetTag_default(value);
-    return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
-  }
-  var isFunction_default = isFunction;
-
-  // ../util-core/src/util/noop.ts
-  var noop = () => {
-  };
-
-  // ../util-core/src/util/deferred.ts
-  var Deferred = class extends Promise {
-    resolve;
-    reject;
-    constructor(executor = noop) {
-      let _resolve, _reject;
-      super((resolve_, reject_) => {
-        _resolve = resolve_;
-        _reject = reject_;
-        return executor(resolve_, reject_);
-      });
-      this.resolve = (value) => {
-        _resolve(value);
-        return this;
-      };
-      this.reject = (reason) => {
-        _reject(reason);
-        return this;
-      };
-    }
-  };
-
-  // ../util-core/src/util/json.ts
-  function tryParseJson(text) {
-    try {
-      return JSON.parse(text || "");
-    } catch {
-      return void 0;
-    }
-  }
-
-  // ../../node_modules/.pnpm/proxy-compare@3.0.1/node_modules/proxy-compare/dist/index.js
-  var TRACK_MEMO_SYMBOL = Symbol();
-  var GET_ORIGINAL_SYMBOL = Symbol();
-  var AFFECTED_PROPERTY = "a";
-  var IS_TARGET_COPIED_PROPERTY = "f";
-  var PROXY_PROPERTY = "p";
-  var PROXY_CACHE_PROPERTY = "c";
-  var TARGET_CACHE_PROPERTY = "t";
-  var HAS_KEY_PROPERTY = "h";
-  var ALL_OWN_KEYS_PROPERTY = "w";
-  var HAS_OWN_KEY_PROPERTY = "o";
-  var KEYS_PROPERTY = "k";
-  var newProxy = (target, handler) => new Proxy(target, handler);
-  var getProto = Object.getPrototypeOf;
-  var objectsToTrack = /* @__PURE__ */ new WeakMap();
-  var isObjectToTrack = (obj) => obj && (objectsToTrack.has(obj) ? objectsToTrack.get(obj) : getProto(obj) === Object.prototype || getProto(obj) === Array.prototype);
-  var isObject2 = (x) => typeof x === "object" && x !== null;
-  var needsToCopyTargetObject = (obj) => Object.values(Object.getOwnPropertyDescriptors(obj)).some((descriptor) => !descriptor.configurable && !descriptor.writable);
-  var copyTargetObject = (obj) => {
-    if (Array.isArray(obj)) {
-      return Array.from(obj);
-    }
-    const descriptors = Object.getOwnPropertyDescriptors(obj);
-    Object.values(descriptors).forEach((desc) => {
-      desc.configurable = true;
-    });
-    return Object.create(getProto(obj), descriptors);
-  };
-  var createProxyHandler = (origObj, isTargetCopied) => {
-    const state = {
-      [IS_TARGET_COPIED_PROPERTY]: isTargetCopied
-    };
-    let trackObject = false;
-    const recordUsage = (type, key) => {
-      if (!trackObject) {
-        let used = state[AFFECTED_PROPERTY].get(origObj);
-        if (!used) {
-          used = {};
-          state[AFFECTED_PROPERTY].set(origObj, used);
-        }
-        if (type === ALL_OWN_KEYS_PROPERTY) {
-          used[ALL_OWN_KEYS_PROPERTY] = true;
-        } else {
-          let set = used[type];
-          if (!set) {
-            set = /* @__PURE__ */ new Set();
-            used[type] = set;
-          }
-          set.add(key);
-        }
-      }
-    };
-    const recordObjectAsUsed = () => {
-      trackObject = true;
-      state[AFFECTED_PROPERTY].delete(origObj);
-    };
-    const handler = {
-      get(target, key) {
-        if (key === GET_ORIGINAL_SYMBOL) {
-          return origObj;
-        }
-        recordUsage(KEYS_PROPERTY, key);
-        return createProxy(Reflect.get(target, key), state[AFFECTED_PROPERTY], state[PROXY_CACHE_PROPERTY], state[TARGET_CACHE_PROPERTY]);
-      },
-      has(target, key) {
-        if (key === TRACK_MEMO_SYMBOL) {
-          recordObjectAsUsed();
-          return true;
-        }
-        recordUsage(HAS_KEY_PROPERTY, key);
-        return Reflect.has(target, key);
-      },
-      getOwnPropertyDescriptor(target, key) {
-        recordUsage(HAS_OWN_KEY_PROPERTY, key);
-        return Reflect.getOwnPropertyDescriptor(target, key);
-      },
-      ownKeys(target) {
-        recordUsage(ALL_OWN_KEYS_PROPERTY);
-        return Reflect.ownKeys(target);
-      }
-    };
-    if (isTargetCopied) {
-      handler.set = handler.deleteProperty = () => false;
-    }
-    return [handler, state];
-  };
-  var getOriginalObject = (obj) => (
-    // unwrap proxy
-    obj[GET_ORIGINAL_SYMBOL] || // otherwise
-    obj
-  );
-  var createProxy = (obj, affected, proxyCache2, targetCache2) => {
-    if (!isObjectToTrack(obj))
-      return obj;
-    let targetAndCopied = targetCache2 && targetCache2.get(obj);
-    if (!targetAndCopied) {
-      const target2 = getOriginalObject(obj);
-      if (needsToCopyTargetObject(target2)) {
-        targetAndCopied = [target2, copyTargetObject(target2)];
-      } else {
-        targetAndCopied = [target2];
-      }
-      targetCache2 === null || targetCache2 === void 0 ? void 0 : targetCache2.set(obj, targetAndCopied);
-    }
-    const [target, copiedTarget] = targetAndCopied;
-    let handlerAndState = proxyCache2 && proxyCache2.get(target);
-    if (!handlerAndState || handlerAndState[1][IS_TARGET_COPIED_PROPERTY] !== !!copiedTarget) {
-      handlerAndState = createProxyHandler(target, !!copiedTarget);
-      handlerAndState[1][PROXY_PROPERTY] = newProxy(copiedTarget || target, handlerAndState[0]);
-      if (proxyCache2) {
-        proxyCache2.set(target, handlerAndState);
-      }
-    }
-    handlerAndState[1][AFFECTED_PROPERTY] = affected;
-    handlerAndState[1][PROXY_CACHE_PROPERTY] = proxyCache2;
-    handlerAndState[1][TARGET_CACHE_PROPERTY] = targetCache2;
-    return handlerAndState[1][PROXY_PROPERTY];
-  };
-  var isAllOwnKeysChanged = (prevObj, nextObj) => {
-    const prevKeys = Reflect.ownKeys(prevObj);
-    const nextKeys = Reflect.ownKeys(nextObj);
-    return prevKeys.length !== nextKeys.length || prevKeys.some((k, i) => k !== nextKeys[i]);
-  };
-  var isChanged = (prevObj, nextObj, affected, cache, isEqual = Object.is) => {
-    if (isEqual(prevObj, nextObj)) {
-      return false;
-    }
-    if (!isObject2(prevObj) || !isObject2(nextObj))
-      return true;
-    const used = affected.get(getOriginalObject(prevObj));
-    if (!used)
-      return true;
-    if (cache) {
-      const hit = cache.get(prevObj);
-      if (hit === nextObj) {
-        return false;
-      }
-      cache.set(prevObj, nextObj);
-    }
-    let changed = null;
-    for (const key of used[HAS_KEY_PROPERTY] || []) {
-      changed = Reflect.has(prevObj, key) !== Reflect.has(nextObj, key);
-      if (changed)
-        return changed;
-    }
-    if (used[ALL_OWN_KEYS_PROPERTY] === true) {
-      changed = isAllOwnKeysChanged(prevObj, nextObj);
-      if (changed)
-        return changed;
-    } else {
-      for (const key of used[HAS_OWN_KEY_PROPERTY] || []) {
-        const hasPrev = !!Reflect.getOwnPropertyDescriptor(prevObj, key);
-        const hasNext = !!Reflect.getOwnPropertyDescriptor(nextObj, key);
-        changed = hasPrev !== hasNext;
-        if (changed)
-          return changed;
-      }
-    }
-    for (const key of used[KEYS_PROPERTY] || []) {
-      changed = isChanged(prevObj[key], nextObj[key], affected, cache, isEqual);
-      if (changed)
-        return changed;
-    }
-    if (changed === null)
-      throw new Error("invalid used");
-    return changed;
-  };
-  var getUntracked = (obj) => {
-    if (isObjectToTrack(obj)) {
-      return obj[GET_ORIGINAL_SYMBOL] || null;
-    }
-    return null;
-  };
-  var markToTrack = (obj, mark = true) => {
-    objectsToTrack.set(obj, mark);
-  };
-  var affectedToPathList = (obj, affected, onlyWithValues) => {
-    const list = [];
-    const seen = /* @__PURE__ */ new WeakSet();
-    const walk = (x, path) => {
-      var _a, _b, _c;
-      if (seen.has(x)) {
-        return;
-      }
-      if (isObject2(x)) {
-        seen.add(x);
-      }
-      const used = isObject2(x) && affected.get(getOriginalObject(x));
-      if (used) {
-        (_a = used[HAS_KEY_PROPERTY]) === null || _a === void 0 ? void 0 : _a.forEach((key) => {
-          const segment = `:has(${String(key)})`;
-          list.push(path ? [...path, segment] : [segment]);
-        });
-        if (used[ALL_OWN_KEYS_PROPERTY] === true) {
-          const segment = ":ownKeys";
-          list.push(path ? [...path, segment] : [segment]);
-        } else {
-          (_b = used[HAS_OWN_KEY_PROPERTY]) === null || _b === void 0 ? void 0 : _b.forEach((key) => {
-            const segment = `:hasOwn(${String(key)})`;
-            list.push(path ? [...path, segment] : [segment]);
-          });
-        }
-        (_c = used[KEYS_PROPERTY]) === null || _c === void 0 ? void 0 : _c.forEach((key) => {
-          if (!onlyWithValues || "value" in (Object.getOwnPropertyDescriptor(x, key) || {})) {
-            walk(x[key], path ? [...path, key] : [key]);
-          }
-        });
-      } else if (path) {
-        list.push(path);
-      }
-    };
-    walk(obj);
-    return list;
-  };
-
-  // ../../node_modules/.pnpm/valtio@2.1.4_@types+react@19.1.6_react@19.1.0/node_modules/valtio/esm/vanilla.mjs
-  var import_meta = {};
-  var isObject3 = (x) => typeof x === "object" && x !== null;
-  var canProxyDefault = (x) => isObject3(x) && !refSet.has(x) && (Array.isArray(x) || !(Symbol.iterator in x)) && !(x instanceof WeakMap) && !(x instanceof WeakSet) && !(x instanceof Error) && !(x instanceof Number) && !(x instanceof Date) && !(x instanceof String) && !(x instanceof RegExp) && !(x instanceof ArrayBuffer) && !(x instanceof Promise);
-  var createSnapshotDefault = (target, version) => {
-    const cache = snapCache.get(target);
-    if ((cache == null ? void 0 : cache[0]) === version) {
-      return cache[1];
-    }
-    const snap = Array.isArray(target) ? [] : Object.create(Object.getPrototypeOf(target));
-    markToTrack(snap, true);
-    snapCache.set(target, [version, snap]);
-    Reflect.ownKeys(target).forEach((key) => {
-      if (Object.getOwnPropertyDescriptor(snap, key)) {
-        return;
-      }
-      const value = Reflect.get(target, key);
-      const { enumerable } = Reflect.getOwnPropertyDescriptor(
-        target,
-        key
-      );
-      const desc = {
-        value,
-        enumerable,
-        // This is intentional to avoid copying with proxy-compare.
-        // It's still non-writable, so it avoids assigning a value.
-        configurable: true
-      };
-      if (refSet.has(value)) {
-        markToTrack(value, false);
-      } else if (proxyStateMap.has(value)) {
-        const [target2, ensureVersion] = proxyStateMap.get(
-          value
-        );
-        desc.value = createSnapshotDefault(target2, ensureVersion());
-      }
-      Object.defineProperty(snap, key, desc);
-    });
-    return Object.preventExtensions(snap);
-  };
-  var createHandlerDefault = (isInitializing, addPropListener, removePropListener, notifyUpdate) => ({
-    deleteProperty(target, prop) {
-      const prevValue = Reflect.get(target, prop);
-      removePropListener(prop);
-      const deleted = Reflect.deleteProperty(target, prop);
-      if (deleted) {
-        notifyUpdate(["delete", [prop], prevValue]);
-      }
-      return deleted;
-    },
-    set(target, prop, value, receiver) {
-      const hasPrevValue = !isInitializing() && Reflect.has(target, prop);
-      const prevValue = Reflect.get(target, prop, receiver);
-      if (hasPrevValue && (objectIs(prevValue, value) || proxyCache.has(value) && objectIs(prevValue, proxyCache.get(value)))) {
-        return true;
-      }
-      removePropListener(prop);
-      if (isObject3(value)) {
-        value = getUntracked(value) || value;
-      }
-      const nextValue = !proxyStateMap.has(value) && canProxy(value) ? proxy(value) : value;
-      addPropListener(prop, nextValue);
-      Reflect.set(target, prop, nextValue, receiver);
-      notifyUpdate(["set", [prop], value, prevValue]);
-      return true;
-    }
-  });
-  var proxyStateMap = /* @__PURE__ */ new WeakMap();
-  var refSet = /* @__PURE__ */ new WeakSet();
-  var snapCache = /* @__PURE__ */ new WeakMap();
-  var versionHolder = [1, 1];
-  var proxyCache = /* @__PURE__ */ new WeakMap();
-  var objectIs = Object.is;
-  var newProxy2 = (target, handler) => new Proxy(target, handler);
-  var canProxy = canProxyDefault;
-  var createSnapshot = createSnapshotDefault;
-  var createHandler = createHandlerDefault;
-  function proxy(baseObject = {}) {
-    if (!isObject3(baseObject)) {
-      throw new Error("object required");
-    }
-    const found = proxyCache.get(baseObject);
-    if (found) {
-      return found;
-    }
-    let version = versionHolder[0];
-    const listeners = /* @__PURE__ */ new Set();
-    const notifyUpdate = (op, nextVersion = ++versionHolder[0]) => {
-      if (version !== nextVersion) {
-        version = nextVersion;
-        listeners.forEach((listener) => listener(op, nextVersion));
-      }
-    };
-    let checkVersion = versionHolder[1];
-    const ensureVersion = (nextCheckVersion = ++versionHolder[1]) => {
-      if (checkVersion !== nextCheckVersion && !listeners.size) {
-        checkVersion = nextCheckVersion;
-        propProxyStates.forEach(([propProxyState]) => {
-          const propVersion = propProxyState[1](nextCheckVersion);
-          if (propVersion > version) {
-            version = propVersion;
-          }
-        });
-      }
-      return version;
-    };
-    const createPropListener = (prop) => (op, nextVersion) => {
-      const newOp = [...op];
-      newOp[1] = [prop, ...newOp[1]];
-      notifyUpdate(newOp, nextVersion);
-    };
-    const propProxyStates = /* @__PURE__ */ new Map();
-    const addPropListener = (prop, propValue) => {
-      const propProxyState = !refSet.has(propValue) && proxyStateMap.get(propValue);
-      if (propProxyState) {
-        if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && propProxyStates.has(prop)) {
-          throw new Error("prop listener already exists");
-        }
-        if (listeners.size) {
-          const remove = propProxyState[2](createPropListener(prop));
-          propProxyStates.set(prop, [propProxyState, remove]);
-        } else {
-          propProxyStates.set(prop, [propProxyState]);
-        }
-      }
-    };
-    const removePropListener = (prop) => {
-      var _a;
-      const entry = propProxyStates.get(prop);
-      if (entry) {
-        propProxyStates.delete(prop);
-        (_a = entry[1]) == null ? void 0 : _a.call(entry);
-      }
-    };
-    const addListener = (listener) => {
-      listeners.add(listener);
-      if (listeners.size === 1) {
-        propProxyStates.forEach(([propProxyState, prevRemove], prop) => {
-          if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && prevRemove) {
-            throw new Error("remove already exists");
-          }
-          const remove = propProxyState[2](createPropListener(prop));
-          propProxyStates.set(prop, [propProxyState, remove]);
-        });
-      }
-      const removeListener = () => {
-        listeners.delete(listener);
-        if (listeners.size === 0) {
-          propProxyStates.forEach(([propProxyState, remove], prop) => {
-            if (remove) {
-              remove();
-              propProxyStates.set(prop, [propProxyState]);
-            }
-          });
-        }
-      };
-      return removeListener;
-    };
-    let initializing = true;
-    const handler = createHandler(
-      () => initializing,
-      addPropListener,
-      removePropListener,
-      notifyUpdate
-    );
-    const proxyObject = newProxy2(baseObject, handler);
-    proxyCache.set(baseObject, proxyObject);
-    const proxyState = [baseObject, ensureVersion, addListener];
-    proxyStateMap.set(proxyObject, proxyState);
-    Reflect.ownKeys(baseObject).forEach((key) => {
-      const desc = Object.getOwnPropertyDescriptor(
-        baseObject,
-        key
-      );
-      if ("value" in desc && desc.writable) {
-        proxyObject[key] = baseObject[key];
-      }
-    });
-    initializing = false;
-    return proxyObject;
-  }
-  function subscribe(proxyObject, callback, notifyInSync) {
-    const proxyState = proxyStateMap.get(proxyObject);
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !proxyState) {
-      console.warn("Please use proxy object");
-    }
-    let promise;
-    const ops = [];
-    const addListener = proxyState[2];
-    let isListenerActive = false;
-    const listener = (op) => {
-      ops.push(op);
-      if (notifyInSync) {
-        callback(ops.splice(0));
-        return;
-      }
-      if (!promise) {
-        promise = Promise.resolve().then(() => {
-          promise = void 0;
-          if (isListenerActive) {
-            callback(ops.splice(0));
-          }
-        });
-      }
-    };
-    const removeListener = addListener(listener);
-    isListenerActive = true;
-    return () => {
-      isListenerActive = false;
-      removeListener();
-    };
-  }
-  function snapshot(proxyObject) {
-    const proxyState = proxyStateMap.get(proxyObject);
-    if ((import_meta.env ? import_meta.env.MODE : void 0) !== "production" && !proxyState) {
-      console.warn("Please use proxy object");
-    }
-    const [target, ensureVersion] = proxyState;
-    return createSnapshot(target, ensureVersion());
-  }
-  function ref(obj) {
-    refSet.add(obj);
-    return obj;
-  }
-  function unstable_getInternalStates() {
-    return {
-      proxyStateMap,
-      refSet,
-      snapCache,
-      versionHolder,
-      proxyCache
-    };
-  }
-
-  // ../../node_modules/.pnpm/valtio@2.1.4_@types+react@19.1.6_react@19.1.0/node_modules/valtio/esm/react.mjs
-  var import_react = __toESM(require_react(), 1);
-  var import_meta2 = {};
-  var useAffectedDebugValue = (state, affected) => {
-    const pathList = (0, import_react.useRef)(void 0);
-    (0, import_react.useEffect)(() => {
-      pathList.current = affectedToPathList(state, affected, true);
-    });
-    (0, import_react.useDebugValue)(pathList.current);
-  };
-  var condUseAffectedDebugValue = useAffectedDebugValue;
-  var targetCache = /* @__PURE__ */ new WeakMap();
-  function useSnapshot(proxyObject, options) {
-    const notifyInSync = options == null ? void 0 : options.sync;
-    const affected = (0, import_react.useMemo)(
-      () => proxyObject && /* @__PURE__ */ new WeakMap(),
-      [proxyObject]
-    );
-    const lastSnapshot = (0, import_react.useRef)(void 0);
-    let inRender = true;
-    const currSnapshot = (0, import_react.useSyncExternalStore)(
-      (0, import_react.useCallback)(
-        (callback) => {
-          const unsub = subscribe(proxyObject, callback, notifyInSync);
-          callback();
-          return unsub;
-        },
-        [proxyObject, notifyInSync]
-      ),
-      () => {
-        const nextSnapshot = snapshot(proxyObject);
-        try {
-          if (!inRender && lastSnapshot.current && !isChanged(
-            lastSnapshot.current,
-            nextSnapshot,
-            affected,
-            /* @__PURE__ */ new WeakMap()
-          )) {
-            return lastSnapshot.current;
-          }
-        } catch (e) {
-        }
-        return nextSnapshot;
-      },
-      () => snapshot(proxyObject)
-    );
-    inRender = false;
-    (0, import_react.useLayoutEffect)(() => {
-      lastSnapshot.current = currSnapshot;
-    });
-    if ((import_meta2.env ? import_meta2.env.MODE : void 0) !== "production") {
-      condUseAffectedDebugValue(currSnapshot, affected);
-    }
-    const proxyCache2 = (0, import_react.useMemo)(() => /* @__PURE__ */ new WeakMap(), []);
-    return createProxy(currSnapshot, affected, proxyCache2, targetCache);
-  }
-
-  // src/utils/track.ts
-  function track(fn, ...args) {
-    const deferred = ref(new Deferred());
-    const exposer = { fn, args, deferred, id: ++Trigger.id };
-    Trigger.tasks.set(exposer.id, exposer);
-    deferred.then(() => Trigger.tasks.delete(exposer.id));
-    return deferred;
-  }
-
-  // src/utils/wrapper.ts
-  var import_react2 = __toESM(require_react(), 1);
-  function wrapper(asChild, props, children) {
-    return asChild ? (0, import_react2.createElement)(asChild, props, children) : children;
-  }
-
-  // src/components/condition/Case.ts
-  function Case(props) {
-    const { cond, children, tag, as: asChild, ...attrs } = props;
-    return wrapper(tag || asChild, attrs, children);
-  }
-
-  // src/components/condition/Default.ts
-  function Default(props) {
-    const { children, tag, as: asChild, ...attrs } = props;
-    return wrapper(tag || asChild, attrs, children);
-  }
-
-  // src/components/condition/If.ts
-  var import_react3 = __toESM(require_react(), 1);
-
-  // src/components/condition/Then.ts
-  function Then(props) {
-    const { children, cond, else: _else, then, tag, as: asChild, ...attrs } = props;
-    return Object.keys(props).includes("cond") ? wrapper(If, props, children) : wrapper(tag || asChild, attrs, children);
-  }
-
-  // src/components/condition/If.ts
-  function If(props) {
-    const { then, cond, else: _else, children = props.then, tag, as: asChild, ...attrs } = props;
-    const elements = import_react3.Children.toArray(children);
-    const thenChild = elements.find((c) => c.type === Then);
-    const elseChild = elements.find((c) => c.type === Else);
-    const child = thenChild || elseChild ? cond ? thenChild : elseChild : cond ? children : _else;
-    return wrapper(tag || asChild, attrs, child);
-  }
-
-  // src/components/condition/Else.ts
-  function Else(props) {
-    const { children, tag, as: asChild, ...attrs } = props;
-    return Object.keys(props).includes("cond") ? wrapper(If, props, children) : wrapper(tag || asChild, attrs, children);
-  }
-
-  // src/components/condition/Switch.ts
-  var import_react4 = __toESM(require_react(), 1);
-  function Switch(props) {
-    const isUseValue = props.value !== void 0;
-    let matchingCase;
-    let defaultCase;
-    import_react4.Children.forEach(props.children, (child) => {
-      if (!(0, import_react4.isValidElement)(child) || matchingCase)
-        return;
-      if (child.type === Case) {
-        const cond = child?.props?.cond;
-        if (isUseValue ? props.value === cond : cond) {
-          matchingCase = child;
-          return;
-        }
-      }
-      if (!defaultCase && child.type === Default)
-        defaultCase = child;
-    });
-    return matchingCase ?? defaultCase ?? null;
-  }
-
-  // src/components/condition/Unless.ts
-  var import_react5 = __toESM(require_react(), 1);
-  function Unless(props) {
-    const { cond, then, else: _else, tag, as: asChild, children = props.then, ...attrs } = props;
-    const elements = import_react5.Children.toArray(children);
-    const thenChild = elements.find((c) => c.type === Then);
-    const elseChild = elements.find((c) => c.type === Else);
-    const child = thenChild || elseChild ? !cond ? elseChild : thenChild : !cond ? children : _else;
-    return wrapper(tag || asChild, attrs, child);
-  }
-
-  // src/components/utils/Injector.ts
-  var import_react6 = __toESM(require_react(), 1);
-  function Injector(props) {
-    const installs = (0, import_react6.useMemo)(
-      () => props.install.map(repack).reverse(),
-      [props.install]
-    );
-    return installs.reduce(
-      (child, { component: Component, props: props2 }) => (0, import_react6.createElement)(Component, props2, child),
-      props.children
-    );
-  }
-  function repack(c) {
-    return c.component ? c : { component: c };
-  }
-
-  // src/components/utils/Trigger.ts
-  var import_react7 = __toESM(require_react(), 1);
-
-  // ../../node_modules/.pnpm/valtio@2.1.4_@types+react@19.1.6_react@19.1.0/node_modules/valtio/esm/vanilla/utils.mjs
-  var currentCleanups;
-  function watch(callback, options) {
-    let alive = true;
-    const cleanups = /* @__PURE__ */ new Set();
-    const subscriptions = /* @__PURE__ */ new Map();
-    const cleanup = () => {
-      if (alive) {
-        alive = false;
-        cleanups.forEach((clean) => clean());
-        cleanups.clear();
-        subscriptions.forEach((unsubscribe) => unsubscribe());
-        subscriptions.clear();
-      }
-    };
-    const revalidate = async () => {
-      if (!alive) {
-        return;
-      }
-      cleanups.forEach((clean) => clean());
-      cleanups.clear();
-      const proxiesToSubscribe = /* @__PURE__ */ new Set();
-      const parent = currentCleanups;
-      currentCleanups = cleanups;
-      try {
-        const promiseOrPossibleCleanup = callback((proxyObject) => {
-          proxiesToSubscribe.add(proxyObject);
-          if (alive && !subscriptions.has(proxyObject)) {
-            const unsubscribe = subscribe(proxyObject, revalidate, options == null ? void 0 : options.sync);
-            subscriptions.set(proxyObject, unsubscribe);
-          }
-          return proxyObject;
-        });
-        const couldBeCleanup = promiseOrPossibleCleanup && promiseOrPossibleCleanup instanceof Promise ? await promiseOrPossibleCleanup : promiseOrPossibleCleanup;
-        if (couldBeCleanup) {
-          if (alive) {
-            cleanups.add(couldBeCleanup);
-          } else {
-            cleanup();
-          }
-        }
-      } finally {
-        currentCleanups = parent;
-      }
-      subscriptions.forEach((unsubscribe, proxyObject) => {
-        if (!proxiesToSubscribe.has(proxyObject)) {
-          subscriptions.delete(proxyObject);
-          unsubscribe();
-        }
-      });
-    };
-    if (currentCleanups) {
-      currentCleanups.add(cleanup);
-    }
-    revalidate();
-    return cleanup;
-  }
-  var DEVTOOLS = Symbol();
-  var { proxyStateMap: proxyStateMap$1, snapCache: snapCache$1 } = unstable_getInternalStates();
-  var isProxy$1 = (x) => proxyStateMap$1.has(x);
-  function proxyMap(entries) {
-    const initialData = [];
-    let initialIndex = 0;
-    const indexMap = /* @__PURE__ */ new Map();
-    const snapMapCache = /* @__PURE__ */ new WeakMap();
-    const registerSnapMap = () => {
-      const cache = snapCache$1.get(vObject);
-      const latestSnap = cache == null ? void 0 : cache[1];
-      if (latestSnap && !snapMapCache.has(latestSnap)) {
-        const clonedMap = new Map(indexMap);
-        snapMapCache.set(latestSnap, clonedMap);
-      }
-    };
-    const getMapForThis = (x) => snapMapCache.get(x) || indexMap;
-    if (entries) {
-      if (typeof entries[Symbol.iterator] !== "function") {
-        throw new TypeError(
-          "proxyMap:\n	initial state must be iterable\n		tip: structure should be [[key, value]]"
-        );
-      }
-      for (const [key, value] of entries) {
-        indexMap.set(key, initialIndex);
-        initialData[initialIndex++] = value;
-      }
-    }
-    const vObject = {
-      data: initialData,
-      index: initialIndex,
-      epoch: 0,
-      get size() {
-        if (!isProxy$1(this)) {
-          registerSnapMap();
-        }
-        const map = getMapForThis(this);
-        return map.size;
-      },
-      get(key) {
-        const map = getMapForThis(this);
-        const index = map.get(key);
-        if (index === void 0) {
-          this.epoch;
-          return void 0;
-        }
-        return this.data[index];
-      },
-      has(key) {
-        const map = getMapForThis(this);
-        this.epoch;
-        return map.has(key);
-      },
-      set(key, value) {
-        if (!isProxy$1(this)) {
-          throw new Error("Cannot perform mutations on a snapshot");
-        }
-        const index = indexMap.get(key);
-        if (index === void 0) {
-          indexMap.set(key, this.index);
-          this.data[this.index++] = value;
-        } else {
-          this.data[index] = value;
-        }
-        this.epoch++;
-        return this;
-      },
-      delete(key) {
-        if (!isProxy$1(this)) {
-          throw new Error("Cannot perform mutations on a snapshot");
-        }
-        const index = indexMap.get(key);
-        if (index === void 0) {
-          return false;
-        }
-        delete this.data[index];
-        indexMap.delete(key);
-        this.epoch++;
-        return true;
-      },
-      clear() {
-        if (!isProxy$1(this)) {
-          throw new Error("Cannot perform mutations on a snapshot");
-        }
-        this.data.length = 0;
-        this.index = 0;
-        this.epoch++;
-        indexMap.clear();
-      },
-      forEach(cb) {
-        this.epoch;
-        const map = getMapForThis(this);
-        map.forEach((index, key) => {
-          cb(this.data[index], key, this);
-        });
-      },
-      *entries() {
-        this.epoch;
-        const map = getMapForThis(this);
-        for (const [key, index] of map) {
-          yield [key, this.data[index]];
-        }
-      },
-      *keys() {
-        this.epoch;
-        const map = getMapForThis(this);
-        for (const key of map.keys()) {
-          yield key;
-        }
-      },
-      *values() {
-        this.epoch;
-        const map = getMapForThis(this);
-        for (const index of map.values()) {
-          yield this.data[index];
-        }
-      },
-      [Symbol.iterator]() {
-        return this.entries();
-      },
-      get [Symbol.toStringTag]() {
-        return "Map";
-      },
-      toJSON() {
-        return new Map(this.entries());
-      }
-    };
-    const proxiedObject = proxy(vObject);
-    Object.defineProperties(proxiedObject, {
-      size: { enumerable: false },
-      index: { enumerable: false },
-      epoch: { enumerable: false },
-      data: { enumerable: false },
-      toJSON: { enumerable: false }
-    });
-    Object.seal(proxiedObject);
-    return proxiedObject;
-  }
-  var { proxyStateMap: proxyStateMap2, snapCache: snapCache2 } = unstable_getInternalStates();
-
-  // src/components/utils/Trigger.ts
-  var pendingTasks = proxyMap();
-  function createTracker(exposer) {
-    const Component = () => {
-      try {
-        exposer.deferred.resolve(exposer.fn(...exposer.args));
-      } catch (error) {
-        exposer.deferred.reject(error);
-      }
-      return null;
-    };
-    Component.key = exposer.id;
-    return Component;
-  }
-  function renderTracker(Tracker) {
-    return (0, import_react7.createElement)(Tracker, { key: Tracker.key });
-  }
-  function Trigger() {
-    const values = [...useSnapshot(pendingTasks).values()];
-    return values.map(createTracker).map(renderTracker);
-  }
-  Trigger.id = 0;
-  Trigger.tasks = pendingTasks;
-
-  // src/hooks/tryUseCallback.ts
-  var import_react8 = __toESM(require_react(), 1);
-  var tryUseCallback = (callback, deps) => {
-    try {
-      return (0, import_react8.useCallback)(callback, deps);
-    } catch {
-      return callback;
-    }
-  };
-
-  // src/hooks/tryUseEffect.ts
-  var import_react9 = __toESM(require_react(), 1);
-  var tryUseEffect = (effect, deps) => {
-    try {
-      (0, import_react9.useEffect)(effect, deps);
-    } catch {
-    }
-  };
-
-  // src/hooks/tryUseInsertionEffect.ts
-  var import_react10 = __toESM(require_react(), 1);
-  var tryUseInsertionEffect = (callback, deps) => {
-    try {
-      (0, import_react10.useInsertionEffect)(callback, deps);
-    } catch {
-    }
-  };
-
-  // src/hooks/tryUseReducer.ts
-  var import_react11 = __toESM(require_react(), 1);
-  var tryUseReducer = (reducer, initializerArg, initializer) => {
-    try {
-      return (0, import_react11.useReducer)(reducer, initializerArg, initializer);
-    } catch {
-      return [initializerArg, () => {
-      }];
-    }
-  };
-
-  // src/hooks/tryUseRef.ts
-  var import_react12 = __toESM(require_react(), 1);
-  var tryUseRef = (initialValue) => {
-    try {
-      return (0, import_react12.useRef)(initialValue);
-    } catch {
-      return { current: initialValue };
-    }
-  };
-
-  // src/hooks/tryUseState.ts
-  var import_react13 = __toESM(require_react(), 1);
-  var tryUseState = (initialState) => {
-    try {
-      return (0, import_react13.useState)(initialState);
-    } catch {
-      return [isFunction_default(initialState) ? initialState() : initialState, noop];
-    }
-  };
-
-  // src/hooks/useUpdate.ts
-  var updateReducer = (num) => (num + 1) % 1e6;
-  function useUpdate() {
-    const [, update] = tryUseReducer(updateReducer, 0);
-    return update;
-  }
-
-  // src/hooks/tryUseUpdate.ts
-  function tryUseUpdate() {
-    try {
-      return useUpdate();
-    } catch {
-      return () => {
-      };
-    }
-  }
-
-  // src/hooks/useAsyncCallback.ts
-  var import_react14 = __toESM(require_react(), 1);
-  function useAsyncCallback(fun) {
-    const [state, set] = (0, import_react14.useState)({ loading: false });
-    async function refetch(...args) {
-      set({ loading: true });
-      return fun(...args).then((value) => {
-        set({ loading: false });
-        return value;
-      }).catch((err) => {
-        set({ loading: false, error: err });
-        return Promise.reject(err);
-      });
-    }
-    return [state.loading, refetch, state.error];
-  }
-
-  // src/hooks/useAsyncState.ts
-  var import_react15 = __toESM(require_react(), 1);
-  function useAsyncState(fun, deps = [], options) {
-    const [value, set] = (0, import_react15.useState)(options?.initial);
-    const [loading, refetch, error] = useAsyncCallback(async (...args) => fun(...args).then(set));
-    (0, import_react15.useEffect)(
-      () => {
-        refetch();
-      },
-      deps
-    );
-    return [{ value, loading, error }, refetch];
-  }
-
-  // src/hooks/useDebounce.ts
-  var import_react16 = __toESM(require_react(), 1);
-  function useDebounce(value, delay) {
-    const [debouncedValue, setDebouncedValue] = (0, import_react16.useState)(value);
-    (0, import_react16.useEffect)(() => {
-      const handler = setTimeout(() => setDebouncedValue(value), delay);
-      return () => clearTimeout(handler);
-    }, [value, delay]);
-    return debouncedValue;
-  }
-
-  // ../../node_modules/.pnpm/mitt@3.0.1/node_modules/mitt/dist/mitt.mjs
-  function mitt_default(n) {
-    return { all: n = n || /* @__PURE__ */ new Map(), on: function(t, e) {
-      var i = n.get(t);
-      i ? i.push(e) : n.set(t, [e]);
-    }, off: function(t, e) {
-      var i = n.get(t);
-      i && (e ? i.splice(i.indexOf(e) >>> 0, 1) : n.set(t, []));
-    }, emit: function(t, e) {
-      var i = n.get(t);
-      i && i.slice().map(function(n2) {
-        n2(e);
-      }), (i = n.get("*")) && i.slice().map(function(n2) {
-        n2(t, e);
-      });
-    } };
-  }
-
-  // src/hooks/useEventBus.ts
-  var import_react17 = __toESM(require_react(), 1);
-  var emitter = mitt_default();
-  function useEventBus(key) {
-    const onRef = (0, import_react17.useRef)(void 0);
-    function on(listener) {
-      emitter.on(key, listener);
-      onRef.current = listener;
-      (0, import_react17.useEffect)(() => {
-        if (!onRef.current)
-          return;
-        emitter.off(key, onRef.current);
-        emitter.on(key, listener);
-        onRef.current = listener;
-        return () => emitter.off(key, listener);
-      }, [listener]);
-    }
-    function emit(event) {
-      emitter.emit(key, event);
-    }
-    function off(listener) {
-      emitter.off(key, listener);
-    }
-    return {
-      on,
-      emit,
-      off
-    };
-  }
-
-  // ../../node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/react-use/esm/useEffectOnce.js
-  var import_react18 = __toESM(require_react());
-  var useEffectOnce = function(effect) {
-    (0, import_react18.useEffect)(effect, []);
-  };
-  var useEffectOnce_default = useEffectOnce;
-
-  // ../../node_modules/.pnpm/react-use@17.6.0_react-dom@19.1.0_react@19.1.0__react@19.1.0/node_modules/react-use/esm/useMount.js
-  var useMount = function(fn) {
-    useEffectOnce_default(function() {
-      fn();
-    });
-  };
-  var useMount_default = useMount;
-
-  // src/hooks/useFetchIntercept.ts
-  function useFetchResponseIntercept(intercept) {
-    useMount_default(() => fetchResponseIntercept(intercept));
-  }
-  function useFetchRequestIntercept(intercept) {
-    useMount_default(() => fetchRequestIntercept(intercept));
-  }
-  function fetchResponseIntercept(intercept) {
-    const { fetch: originalFetch } = window;
-    window.fetch = async (...args) => {
-      const [resource, config] = args;
-      const response = await originalFetch(resource, config);
-      return intercept(response, config);
-    };
-  }
-  function fetchRequestIntercept(intercept) {
-    const { fetch: originalFetch } = window;
-    window.fetch = async (...args) => {
-      const [resource, config] = args;
-      return intercept(originalFetch, resource, config);
-    };
-  }
-
-  // src/hooks/useMounted.ts
-  var import_react19 = __toESM(require_react(), 1);
-  function useMounted() {
-    const [mounted, setMounted] = (0, import_react19.useState)(false);
-    (0, import_react19.useEffect)(() => setMounted(true), []);
-    return mounted;
-  }
-
-  // src/hooks/useOffsetPagination.ts
-  var import_react22 = __toESM(require_react(), 1);
-
-  // src/hooks/useWatch.ts
-  var import_react21 = __toESM(require_react(), 1);
-
-  // src/hooks/usePrevious.ts
-  var import_react20 = __toESM(require_react(), 1);
-  function usePrevious(value) {
-    const ref2 = (0, import_react20.useRef)(void 0);
-    (0, import_react20.useEffect)(() => {
-      ref2.current = value;
-    });
-    return ref2.current;
-  }
-
-  // src/hooks/useWatch.ts
-  function useWatch(source, callback, options = {}) {
-    const firstUpdate = (0, import_react21.useRef)(false);
-    const then = (0, import_react21.useRef)(void 0);
-    const oldValue = usePrevious(source);
-    const deps = (0, import_react21.useMemo)(
-      () => Array.isArray(source) ? source : [source],
-      [source]
-    );
-    (0, import_react21.useEffect)(() => {
-      if (!firstUpdate.current)
-        recordFirst();
-      else
-        callback(source, oldValue);
-    }, deps);
-    async function recordFirst() {
-      if (then.current)
-        return;
-      then.current = Promise.resolve(source);
-      then.current.then(() => firstUpdate.current = true);
-      if (options.immediate)
-        then.current.then((value) => callback(value, oldValue));
-    }
-  }
-
-  // src/hooks/useOffsetPagination.ts
-  function useOffsetPagination(options) {
-    const [page, setPage] = (0, import_react22.useState)(options.page || 1);
-    const [pageSize, setPageSize] = (0, import_react22.useState)(options.pageSize || 10);
-    const total = options.total || 0;
-    const pageCount = (0, import_react22.useMemo)(() => Math.max(1, Math.ceil(total / pageSize)), [total, pageSize]);
-    const isFirstPage = (0, import_react22.useMemo)(() => page === 1, [page]);
-    const isLastPage = (0, import_react22.useMemo)(() => page === pageCount, [page, pageCount]);
-    function next() {
-      setPage((page2) => Math.min(pageCount, page2 + 1));
-    }
-    function prev() {
-      setPage((page2) => Math.max(1, page2 - 1));
-    }
-    function pageChange(page2) {
-      setPage(() => Math.max(1, Math.min(page2, pageCount)));
-    }
-    function pageSizeChange(limit) {
-      setPageSize(limit);
-      pageChange(1);
-    }
-    const pagination = {
-      next,
-      prev,
-      page,
-      pageSize,
-      isFirstPage,
-      pageSizeChange,
-      pageChange,
-      isLastPage,
-      pageCount,
-      total
-    };
-    useWatch(page, () => options.onChange?.(pagination));
-    useWatch(pageSize, () => options.onPageSizeChange?.(pagination));
-    useWatch(pageCount, () => options.onPageCountChange?.(pagination));
-    return pagination;
-  }
-
-  // src/hooks/useWhenever.ts
-  function useWhenever(source, cb, options) {
-    useWatch(source, (value, oldValue) => value && cb(value, oldValue), options);
-  }
-
-  // src/storage/defineStore.ts
-  var import_react23 = __toESM(require_react(), 1);
-
-  // src/storage/persistant.ts
-  function proxyWithPersistant(keyOrOptions, initialObject) {
-    let options;
-    if (typeof keyOrOptions === "string") {
-      options = { id: keyOrOptions };
-    } else {
-      options = { ...keyOrOptions };
-    }
-    const storage = options.storage || (typeof localStorage !== "undefined" ? localStorage : void 0);
-    typeof keyOrOptions === "string" && (keyOrOptions = { id: keyOrOptions });
-    const state = proxy(tryParseJson(storage?.getItem(options.id)) || initialObject);
-    subscribe(state, () => {
-      const pick = options.pick || Object.keys(state);
-      const statePick = {};
-      for (const key of pick)
-        statePick[key] = state[key];
-      storage?.setItem(options.id, JSON.stringify(statePick));
-    });
-    return state;
-  }
-
-  // src/storage/utils/index.ts
-  function track2(action, status) {
-    let loadings = 0;
-    const tracking = () => loadings++ === 0 && (status.loading = true);
-    const done = () => !--loadings && (status.loading = false);
-    const fulfilled = (value) => {
-      status.finished = true;
-      done();
-      return value;
-    };
-    const rejected = (error) => {
-      status.error = error;
-      done();
-      throw error;
-    };
-    return function(...args) {
-      tracking();
-      try {
-        const value = action(...args);
-        return value instanceof Promise ? value.then(fulfilled, rejected) : fulfilled(value);
-      } catch (error) {
-        rejected(error);
-      }
-    };
-  }
-
-  // src/storage/defineStore.ts
-  function defineStore(store, options = {}) {
-    const state = typeof store.state === "function" ? store.state() : store.state;
-    const getters = store.getters || {};
-    const actions = store.actions || {};
-    const status = {};
-    status.finished = false;
-    status.loading = false;
-    status.error = null;
-    const $status = proxy(status);
-    const $state = options.persist ? proxyWithPersistant(options.persist, state) : proxy(state);
-    const $actions = {};
-    const $getters = {};
-    setupActions($state, actions, $actions, $status);
-    setupGetters(state, $state, getters, $getters);
-    setupStatus($actions, $status);
-    function $subscribe(listener) {
-      return subscribe($state, () => listener($state));
-    }
-    $subscribe.status = function(listener) {
-      return subscribe($status, () => listener($status));
-    };
-    function $patch(patch) {
-      if (typeof patch === "function")
-        patch($state);
-      else
-        Object.assign($state, patch);
-    }
-    function $signal(fn) {
-      return (0, import_react23.createElement)(() => fn(useSnapshot($state)));
-    }
-    $signal.status = function(fn) {
-      return (0, import_react23.createElement)(() => fn(useSnapshot($status)));
-    };
-    return {
-      $subscribe,
-      $patch,
-      $state,
-      $status,
-      $actions,
-      $getters,
-      $signal,
-      ...$actions
-    };
-  }
-  function setupActions($state, actions, $actions, $status) {
-    for (const key in actions) {
-      $status[key] = { finished: false, loading: false, error: null };
-      $actions[key] = track2(actions[key].bind($state), $status[key]);
-      Object.defineProperty($state, key, {
-        get: () => $actions[key]
-      });
-    }
-  }
-  function setupGetters(state, $state, getters, $getters) {
-    for (const key in getters) {
-      Object.defineProperty(state, key, {
-        get: () => getters[key].call($state),
-        enumerable: true
-      });
-      Object.defineProperty($getters, key, {
-        get: () => state[key],
-        enumerable: true
-      });
-    }
-  }
-  function setupStatus($actions, $status) {
-    Object.defineProperty($status, "loading", {
-      get: () => Object.keys($actions).some((key) => $status[key].loading),
-      enumerable: true
-    });
-    Object.defineProperty($status, "finished", {
-      get: () => Object.keys($actions).every((key) => $status[key].finished),
-      enumerable: true
-    });
-    Object.defineProperty($status, "error", {
-      get: () => Object.keys($actions).find((key) => $status[key].error),
-      enumerable: true
-    });
-  }
-
-  // src/storage/defineStoreAsync.ts
-  function defineStoreAsync(fetch, options = {}) {
-    let persist;
-    if (typeof options.persist === "string") {
-      persist = { id: options.persist, pick: ["value"] };
-    }
-    if (typeof options.persist === "object") {
-      persist = { ...options.persist, pick: ["value"] };
-    }
-    const store = defineStore(
-      {
-        state: () => ({
-          value: options.initial,
-          error: void 0,
-          loading: false,
-          finished: false
-        }),
-        actions: {
-          async refetch(...args) {
-            return this.value = await fetch(...args);
-          },
-          reset(value) {
-            this.value = value || options.initial;
-          }
-        }
-      },
-      { persist }
-    );
-    watch((get) => {
-      const status = get(store.$status.refetch);
-      store.$state.error = status.error;
-      store.$state.loading = status.loading;
-      store.$state.finished = status.finished;
-    });
-    options.immediate && store.refetch();
-    return store;
-  }
-  var defienAsyncStore = defineStoreAsync;
-
-  // src/storage/useStatus.tsx
-  function useStatus(store) {
-    return useSnapshot(store.$status);
-  }
-
-  // src/storage/useStore.ts
-  function useStore(store) {
-    return useSnapshot(store.$state);
-  }
-  return __toCommonJS(index_exports);
-})();
-/*! Bundled license information:
-
-lodash-es/lodash.js:
-  (**
-   * @license
-   * Lodash (Custom Build) <https://lodash.com/>
-   * Build: `lodash modularize exports="es" -o ./`
-   * Copyright OpenJS Foundation and other contributors <https://openjsf.org/>
-   * Released under MIT license <https://lodash.com/license>
-   * Based on Underscore.js 1.8.3 <http://underscorejs.org/LICENSE>
-   * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
-   *)
-*/