storion 0.8.3 → 0.10.0

package/dist/storion.js

@@ -1,46 +1,920 @@
-import { S, n, m, c, l, u, q, o, g, a, h, d, f, k, i, e, j, b, z, p, t, s, v, w, y, A, x } from "./index-C8B6Mo8r.js";
-import { A as A2, E, H, I, c as c2, L, P, a as a2, d as d2, S as S2, b as b2, e as e2, u as u2 } from "./effect-C6h0PDDI.js";
+import { C as tryDispose, i as isSpec, u as untrack, k as STORION_TYPE, D as unwrapFn, q as shallowEqual, l as resolveEquality } from "./effect-BDQU8Voz.js";
+import { d, E, H, I, L, z, P, S, y, x, n, v, e, o, m, p, B, a, h } from "./effect-BDQU8Voz.js";
+import { e as emitter } from "./emitter-j4rC71vY.js";
 import { m as m2 } from "./meta-40r-AZfe.js";
+function createMetaQuery(entries) {
+  const entryArray = Array.isArray(entries) ? entries : entries ? [entries] : [];
+  const single = (type) => {
+    const result = { store: void 0, fields: {} };
+    for (const entry of entryArray) {
+      if (entry.type !== type) continue;
+      if (entry.fields && entry.fields.length > 0) {
+        for (const field of entry.fields) {
+          const fieldKey = field;
+          if (!(fieldKey in result.fields)) {
+            result.fields[fieldKey] = entry.value;
+          }
+        }
+      } else {
+        if (result.store === void 0) {
+          result.store = entry.value;
+        }
+      }
+    }
+    return result;
+  };
+  const all = (type) => {
+    const result = { store: [], fields: {} };
+    for (const entry of entryArray) {
+      if (entry.type !== type) continue;
+      if (entry.fields && entry.fields.length > 0) {
+        for (const field of entry.fields) {
+          const fieldKey = field;
+          let arr = result.fields[fieldKey];
+          if (!arr) {
+            arr = [];
+            result.fields[fieldKey] = arr;
+          }
+          arr.push(entry.value);
+        }
+      } else {
+        result.store.push(entry.value);
+      }
+    }
+    return result;
+  };
+  const fields = (type, predicate) => {
+    const result = /* @__PURE__ */ new Set();
+    for (const entry of entryArray) {
+      if (entry.type !== type) continue;
+      if (entry.fields && entry.fields.length > 0) {
+        if (!predicate || predicate(entry.value)) {
+          for (const field of entry.fields) {
+            result.add(field);
+          }
+        }
+      }
+    }
+    return Array.from(result);
+  };
+  const any = (...types) => {
+    return entryArray.some((entry) => types.includes(entry.type));
+  };
+  const query = Object.assign(
+    (type) => single(type),
+    { all, any, fields }
+  );
+  return query;
+}
+function extractDisplayName(factory) {
+  if (isSpec(factory)) {
+    return factory.displayName;
+  }
+  if (typeof factory.displayName === "string" && factory.displayName) {
+    return factory.displayName;
+  }
+  if (factory.name && factory.name !== "") {
+    return factory.name;
+  }
+  return void 0;
+}
+function createResolver(options = {}) {
+  const {
+    middleware = [],
+    parent,
+    invokeResolver: invokeResolverOption
+  } = options;
+  const cache2 = /* @__PURE__ */ new Map();
+  const overrides = /* @__PURE__ */ new Map();
+  const resolve = (factory) => overrides.get(factory) ?? factory;
+  const invoke = (factory, resolverForCtx) => {
+    const isStoreSpec = isSpec(factory);
+    const displayName = extractDisplayName(factory);
+    const meta = createMetaQuery(factory.meta);
+    const chain = middleware.reduceRight(
+      (next, mw) => () => {
+        if (isStoreSpec) {
+          const ctx = {
+            type: "store",
+            factory,
+            resolver: resolverForCtx,
+            next,
+            displayName,
+            spec: factory,
+            meta
+          };
+          return mw(ctx);
+        } else {
+          const ctx = {
+            type: "service",
+            factory,
+            resolver: resolverForCtx,
+            next,
+            displayName,
+            meta
+          };
+          return mw(ctx);
+        }
+      },
+      () => factory(resolverForCtx)
+    );
+    return chain();
+  };
+  const resolver = {
+    get(factory) {
+      if (cache2.has(factory)) {
+        return cache2.get(factory);
+      }
+      if (parent && overrides.size === 0 && parent.has(factory)) {
+        return parent.get(factory);
+      }
+      const instance = invoke(
+        resolve(factory),
+        invokeResolverOption ?? resolver
+      );
+      cache2.set(factory, instance);
+      return instance;
+    },
+    create(factory, ...args) {
+      const resolverForCtx = invokeResolverOption ?? resolver;
+      if (args.length > 0) {
+        return factory(resolverForCtx, ...args);
+      }
+      return invoke(resolve(factory), resolverForCtx);
+    },
+    set(factory, override) {
+      overrides.set(factory, override);
+      cache2.delete(factory);
+    },
+    has(factory) {
+      const inParent = parent && overrides.size === 0 && parent.has(factory);
+      return cache2.has(factory) || (inParent ?? false);
+    },
+    tryGet(factory) {
+      if (cache2.has(factory)) {
+        return cache2.get(factory);
+      }
+      if (parent && overrides.size === 0) {
+        return parent.tryGet(factory);
+      }
+      return void 0;
+    },
+    delete(factory) {
+      const instance = cache2.get(factory);
+      if (instance) {
+        tryDispose(instance);
+        cache2.delete(factory);
+        return true;
+      }
+      return false;
+    },
+    clear() {
+      for (const instance of cache2.values()) {
+        tryDispose(instance);
+      }
+      cache2.clear();
+    },
+    scope(scopeOptions = {}) {
+      return createResolver({
+        middleware: scopeOptions.middleware ?? middleware,
+        parent: resolver,
+        ...scopeOptions
+      });
+    }
+  };
+  return resolver;
+}
+let defaultMiddlewareConfig = {};
+const container = function(options = {}) {
+  const middleware = [
+    ...defaultMiddlewareConfig.pre ?? [],
+    ...Array.isArray(options.middleware) ? options.middleware : options.middleware ? [options.middleware] : [],
+    ...defaultMiddlewareConfig.post ?? []
+  ];
+  const instancesById = /* @__PURE__ */ new Map();
+  const creationOrder = [];
+  const createEmitter = emitter();
+  const disposeEmitter = emitter();
+  const parent = options._parent;
+  let containerApi;
+  const internalResolver = createResolver({
+    middleware,
+    parent,
+    get invokeResolver() {
+      return containerApi;
+    }
+  });
+  function trackStore(spec, instance) {
+    instancesById.set(instance.id, instance);
+    creationOrder.push(spec);
+    if (typeof instance.onDispose === "function") {
+      instance.onDispose(() => {
+        disposeEmitter.emit(instance);
+        instancesById.delete(instance.id);
+        internalResolver.delete(spec);
+        const index = creationOrder.indexOf(spec);
+        if (index !== -1) {
+          creationOrder.splice(index, 1);
+        }
+      });
+    }
+    createEmitter.emit(instance);
+  }
+  containerApi = {
+    [STORION_TYPE]: "container",
+    // Get by ID or factory/spec
+    get(specOrIdOrFactory) {
+      if (typeof specOrIdOrFactory === "string") {
+        return instancesById.get(specOrIdOrFactory);
+      }
+      const wasCached = internalResolver.has(specOrIdOrFactory);
+      const instance = untrack(() => internalResolver.get(specOrIdOrFactory));
+      if (!wasCached && isSpec(specOrIdOrFactory)) {
+        trackStore(specOrIdOrFactory, instance);
+      }
+      return instance;
+    },
+    create(specOrFactory, ...args) {
+      const instance = untrack(
+        () => internalResolver.create(specOrFactory, ...args)
+      );
+      if (isSpec(specOrFactory)) {
+        const storeInstance = instance;
+        instancesById.set(storeInstance.id, storeInstance);
+        if (typeof storeInstance.onDispose === "function") {
+          storeInstance.onDispose(() => {
+            disposeEmitter.emit(storeInstance);
+            instancesById.delete(storeInstance.id);
+          });
+        }
+      }
+      return instance;
+    },
+    set(spec, override) {
+      const existing = internalResolver.tryGet(spec);
+      tryDispose(existing);
+      internalResolver.set(spec, override);
+    },
+    has(spec) {
+      return internalResolver.has(spec);
+    },
+    tryGet(spec) {
+      return internalResolver.tryGet(spec);
+    },
+    delete(spec) {
+      const instance = internalResolver.tryGet(spec);
+      if (instance) {
+        tryDispose(instance);
+        return true;
+      }
+      return false;
+    },
+    clear() {
+      const specs = [...creationOrder].reverse();
+      for (const spec of specs) {
+        const instance = internalResolver.tryGet(spec);
+        tryDispose(instance);
+      }
+      internalResolver.clear();
+      instancesById.clear();
+      creationOrder.length = 0;
+    },
+    dispose(spec) {
+      return containerApi.delete(spec);
+    },
+    scope(scopeOptions = {}) {
+      return container({
+        middleware: scopeOptions.middleware ?? middleware,
+        _parent: containerApi
+      });
+    },
+    onCreate: createEmitter.on,
+    onDispose: disposeEmitter.on
+  };
+  return containerApi;
+};
+const defaultsFn = (config = {}) => {
+  defaultMiddlewareConfig = {
+    pre: [...defaultMiddlewareConfig.pre ?? [], ...config.pre ?? []],
+    post: [...defaultMiddlewareConfig.post ?? [], ...config.post ?? []]
+  };
+};
+defaultsFn.clear = () => {
+  defaultMiddlewareConfig = {};
+};
+container.defaults = defaultsFn;
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function createDisposalTracker() {
+  let pendingDisposedItems = /* @__PURE__ */ new Set();
+  let disposalScheduled = false;
+  return {
+    /**
+     * Schedule items for async disposal.
+     * Items will be disposed in a microtask unless cancelled.
+     * Only objects are tracked - primitives are skipped.
+     */
+    scheduleDisposal(items) {
+      if (items.length === 0) return;
+      const newPending = new Set(pendingDisposedItems);
+      let hasNewItems = false;
+      for (const item of items) {
+        if (isObject(item)) {
+          newPending.add(item);
+          hasNewItems = true;
+        }
+      }
+      if (!hasNewItems) return;
+      pendingDisposedItems = newPending;
+      if (!disposalScheduled) {
+        disposalScheduled = true;
+        queueMicrotask(() => {
+          disposalScheduled = false;
+          const toDispose = pendingDisposedItems;
+          pendingDisposedItems = /* @__PURE__ */ new Set();
+          for (const item of toDispose) {
+            tryDispose(item);
+          }
+        });
+      }
+    },
+    /**
+     * Cancel disposal for items that are being re-added.
+     * Call this when items are pushed/inserted back into the collection.
+     * Only objects are checked - primitives are skipped.
+     */
+    cancelDisposal(items) {
+      if (items.length === 0 || pendingDisposedItems.size === 0) return;
+      let hasChanges = false;
+      for (const item of items) {
+        if (isObject(item) && pendingDisposedItems.has(item)) {
+          hasChanges = true;
+          break;
+        }
+      }
+      if (!hasChanges) return;
+      const newPending = new Set(pendingDisposedItems);
+      for (const item of items) {
+        if (isObject(item)) {
+          newPending.delete(item);
+        }
+      }
+      pendingDisposedItems = newPending;
+    },
+    /**
+     * Check if an item is pending disposal.
+     */
+    isPending(item) {
+      return isObject(item) && pendingDisposedItems.has(item);
+    }
+  };
+}
+function toggle() {
+  return (prev) => !prev;
+}
+function increment(amount = 1) {
+  return (prev) => (prev ?? 0) + amount;
+}
+function decrement(amount = 1) {
+  return (prev) => (prev ?? 0) - amount;
+}
+function multiply(factor) {
+  return (prev) => (prev ?? 0) * factor;
+}
+function divide(divisor) {
+  return (prev) => (prev ?? 0) / divisor;
+}
+function clamp(min, max) {
+  return (prev) => Math.min(max, Math.max(min, prev ?? 0));
+}
+function append(suffix) {
+  return (prev) => (prev ?? "") + suffix;
+}
+function prepend(prefix) {
+  return (prev) => prefix + (prev ?? "");
+}
+function merge(partial) {
+  return (prev) => ({ ...prev, ...partial });
+}
+function reset(defaultValue) {
+  return () => defaultValue;
+}
+function list(options) {
+  const autoDispose = (options == null ? void 0 : options.autoDispose) ?? false;
+  return (inputFocus) => {
+    const focus = inputFocus;
+    const [getter, setter] = focus;
+    const defaultValue = [];
+    const tracker = autoDispose ? createDisposalTracker() : null;
+    const getArray = () => getter() ?? defaultValue;
+    const scheduleDisposal = (items) => {
+      tracker == null ? void 0 : tracker.scheduleDisposal(items);
+    };
+    const cancelDisposal = (items) => {
+      tracker == null ? void 0 : tracker.cancelDisposal(items);
+    };
+    return {
+      get() {
+        return getArray();
+      },
+      at(index) {
+        return getArray()[index];
+      },
+      length() {
+        return getArray().length;
+      },
+      isEmpty() {
+        return getArray().length === 0;
+      },
+      first() {
+        return getArray()[0];
+      },
+      last() {
+        const arr = getArray();
+        return arr[arr.length - 1];
+      },
+      push(...items) {
+        cancelDisposal(items);
+        setter((draft) => {
+          const arr = draft ?? [];
+          arr.push(...items);
+          return arr;
+        });
+      },
+      unshift(...items) {
+        cancelDisposal(items);
+        setter((draft) => {
+          const arr = draft ?? [];
+          arr.unshift(...items);
+          return arr;
+        });
+      },
+      pop() {
+        const currentArray = getArray();
+        if (currentArray.length === 0) return void 0;
+        const removed = currentArray[currentArray.length - 1];
+        setter((draft) => {
+          const arr = draft ?? [];
+          arr.pop();
+          return arr;
+        });
+        scheduleDisposal([removed]);
+        return removed;
+      },
+      shift() {
+        const currentArray = getArray();
+        if (currentArray.length === 0) return void 0;
+        const removed = currentArray[0];
+        setter((draft) => {
+          const arr = draft ?? [];
+          arr.shift();
+          return arr;
+        });
+        scheduleDisposal([removed]);
+        return removed;
+      },
+      remove(...items) {
+        const currentArray = getArray();
+        const indicesToRemove = [];
+        const removed = [];
+        for (const item of items) {
+          const index = currentArray.indexOf(item);
+          if (index !== -1 && !indicesToRemove.includes(index)) {
+            indicesToRemove.push(index);
+            removed.push(item);
+          }
+        }
+        if (removed.length === 0) return 0;
+        indicesToRemove.sort((a2, b) => b - a2);
+        setter((draft) => {
+          const arr = draft ?? [];
+          for (const idx of indicesToRemove) {
+            arr.splice(idx, 1);
+          }
+          return arr;
+        });
+        scheduleDisposal(removed);
+        return removed.length;
+      },
+      removeAt(index) {
+        const currentArray = getArray();
+        if (index < 0 || index >= currentArray.length) return void 0;
+        const removed = currentArray[index];
+        setter((draft) => {
+          const arr = draft ?? [];
+          arr.splice(index, 1);
+          return arr;
+        });
+        scheduleDisposal([removed]);
+        return removed;
+      },
+      removeWhere(predicate) {
+        const currentArray = getArray();
+        const indicesToRemove = [];
+        const removed = [];
+        for (let i = 0; i < currentArray.length; i++) {
+          if (predicate(currentArray[i], i)) {
+            indicesToRemove.push(i);
+            removed.push(currentArray[i]);
+          }
+        }
+        if (removed.length === 0) return 0;
+        indicesToRemove.sort((a2, b) => b - a2);
+        setter((draft) => {
+          const arr = draft ?? [];
+          for (const idx of indicesToRemove) {
+            arr.splice(idx, 1);
+          }
+          return arr;
+        });
+        scheduleDisposal(removed);
+        return removed.length;
+      },
+      insert(index, ...items) {
+        cancelDisposal(items);
+        setter((draft) => {
+          const arr = draft ?? [];
+          arr.splice(index, 0, ...items);
+          return arr;
+        });
+      },
+      set(index, itemOrReducerOrUpdater) {
+        const isFunction = typeof itemOrReducerOrUpdater === "function";
+        const currentArray = getArray();
+        if (isFunction && (index < 0 || index >= currentArray.length)) {
+          return;
+        }
+        if (!isFunction) {
+          cancelDisposal([itemOrReducerOrUpdater]);
+        }
+        const old = index >= 0 && index < currentArray.length ? currentArray[index] : void 0;
+        setter((draft) => {
+          const arr = draft ?? [];
+          if (isFunction) {
+            const fn = itemOrReducerOrUpdater;
+            if (index >= 0 && index < arr.length) {
+              const result = fn(arr[index]);
+              if (result !== void 0) {
+                arr[index] = result;
+              }
+            }
+          } else {
+            arr[index] = itemOrReducerOrUpdater;
+          }
+          return arr;
+        });
+        const newValue = getArray()[index];
+        if (old !== void 0 && old !== newValue) scheduleDisposal([old]);
+      },
+      clear() {
+        const old = getArray();
+        setter([]);
+        scheduleDisposal(old);
+      },
+      replace(items) {
+        cancelDisposal(items);
+        const old = getArray();
+        setter(items);
+        const toDispose = old.filter((item) => !items.includes(item));
+        scheduleDisposal(toDispose);
+      },
+      find(predicate) {
+        return getArray().find(predicate);
+      },
+      findIndex(predicate) {
+        return getArray().findIndex(predicate);
+      },
+      includes(item) {
+        return getArray().includes(item);
+      },
+      map(fn) {
+        return getArray().map(fn);
+      },
+      filter(predicate) {
+        return getArray().filter(predicate);
+      },
+      pick(equality) {
+        return focus.pick(equality) ?? defaultValue;
+      }
+    };
+  };
+}
+function map(options) {
+  const autoDispose = (options == null ? void 0 : options.autoDispose) ?? false;
+  const defaultValue = {};
+  return (inputFocus) => {
+    const focus = inputFocus;
+    const [getter, setter] = focus;
+    const tracker = autoDispose ? createDisposalTracker() : null;
+    const getRecord = () => getter() ?? defaultValue;
+    const scheduleDisposal = (items) => {
+      tracker == null ? void 0 : tracker.scheduleDisposal(items);
+    };
+    const cancelDisposal = (items) => {
+      tracker == null ? void 0 : tracker.cancelDisposal(items);
+    };
+    return {
+      get: getRecord,
+      at(key) {
+        return getRecord()[key];
+      },
+      size() {
+        return Object.keys(getRecord()).length;
+      },
+      isEmpty() {
+        return Object.keys(getRecord()).length === 0;
+      },
+      has(key) {
+        return key in getRecord();
+      },
+      set(key, valueOrReducerOrUpdater) {
+        const isFunction = typeof valueOrReducerOrUpdater === "function";
+        const currentRecord = getRecord();
+        if (isFunction && !(key in currentRecord)) return;
+        if (!isFunction) {
+          cancelDisposal([valueOrReducerOrUpdater]);
+        }
+        const old = currentRecord[key];
+        setter((draft) => {
+          const rec = draft ?? {};
+          if (isFunction) {
+            const fn = valueOrReducerOrUpdater;
+            const result = fn(rec[key]);
+            if (result !== void 0) {
+              rec[key] = result;
+            }
+          } else {
+            rec[key] = valueOrReducerOrUpdater;
+          }
+          return rec;
+        });
+        const newValue = getRecord()[key];
+        if (old !== void 0 && old !== newValue) scheduleDisposal([old]);
+      },
+      delete(...keys) {
+        const currentRecord = getRecord();
+        const removed = [];
+        const keysToDelete = [];
+        for (const key of keys) {
+          if (key in currentRecord) {
+            removed.push(currentRecord[key]);
+            keysToDelete.push(key);
+          }
+        }
+        if (removed.length === 0) return 0;
+        setter((draft) => {
+          const rec = draft ?? {};
+          for (const key of keysToDelete) {
+            delete rec[key];
+          }
+          return rec;
+        });
+        scheduleDisposal(removed);
+        return removed.length;
+      },
+      deleteWhere(predicate) {
+        const currentRecord = getRecord();
+        const removed = [];
+        const keysToDelete = [];
+        for (const key of Object.keys(currentRecord)) {
+          if (predicate(currentRecord[key], key)) {
+            removed.push(currentRecord[key]);
+            keysToDelete.push(key);
+          }
+        }
+        if (removed.length === 0) return 0;
+        setter((draft) => {
+          const rec = draft ?? {};
+          for (const key of keysToDelete) {
+            delete rec[key];
+          }
+          return rec;
+        });
+        scheduleDisposal(removed);
+        return removed.length;
+      },
+      clear() {
+        const old = Object.values(getRecord());
+        setter({});
+        scheduleDisposal(old);
+      },
+      replace(record) {
+        cancelDisposal(Object.values(record));
+        const old = getRecord();
+        setter(record);
+        const newKeys = new Set(Object.keys(record));
+        const toDispose = Object.entries(old).filter(([key]) => !newKeys.has(key)).map(([, value]) => value);
+        scheduleDisposal(toDispose);
+      },
+      keys() {
+        return Object.keys(getRecord());
+      },
+      values() {
+        return Object.values(getRecord());
+      },
+      entries() {
+        return Object.entries(getRecord());
+      },
+      pick(equality) {
+        return focus.pick(equality) ?? defaultValue;
+      }
+    };
+  };
+}
+function patternToPredicate(pattern) {
+  if (pattern instanceof RegExp) {
+    return (name) => pattern.test(name);
+  }
+  const startsWithWildcard = pattern.startsWith("*");
+  const endsWithWildcard = pattern.endsWith("*");
+  if (startsWithWildcard && endsWithWildcard) {
+    const substr = pattern.slice(1, -1);
+    return (name) => name.includes(substr);
+  }
+  if (startsWithWildcard) {
+    const suffix = pattern.slice(1);
+    return (name) => name.endsWith(suffix);
+  }
+  if (endsWithWildcard) {
+    const prefix = pattern.slice(0, -1);
+    return (name) => name.startsWith(prefix);
+  }
+  return (name) => name === pattern;
+}
+function patternsToPredicate(patterns) {
+  if (Array.isArray(patterns)) {
+    const predicates = patterns.map(patternToPredicate);
+    return (ctx) => ctx.displayName !== void 0 && predicates.some((p2) => p2(ctx.displayName));
+  }
+  const predicate = patternToPredicate(patterns);
+  return (ctx) => ctx.displayName !== void 0 && predicate(ctx.displayName);
+}
+function compose(...middlewares) {
+  if (middlewares.length === 0) {
+    return (ctx) => ctx.next();
+  }
+  if (middlewares.length === 1) {
+    return middlewares[0];
+  }
+  return (ctx) => {
+    let index = 0;
+    const executeNext = () => {
+      if (index >= middlewares.length) {
+        return ctx.next();
+      }
+      const currentMiddleware = middlewares[index];
+      index++;
+      const wrappedCtx = ctx.type === "store" ? { ...ctx, next: executeNext } : { ...ctx, next: executeNext };
+      return currentMiddleware(wrappedCtx);
+    };
+    return executeNext();
+  };
+}
+function applyFor(predicateOrPatternsOrMap, middleware) {
+  if (typeof predicateOrPatternsOrMap === "object" && !Array.isArray(predicateOrPatternsOrMap) && !(predicateOrPatternsOrMap instanceof RegExp)) {
+    const entries = Object.entries(predicateOrPatternsOrMap);
+    const pairs = entries.map(([pattern, mw]) => ({
+      predicate: patternsToPredicate(pattern),
+      middleware: Array.isArray(mw) ? compose(...mw) : mw
+    }));
+    return (ctx) => {
+      for (const { predicate: predicate2, middleware: middleware2 } of pairs) {
+        if (predicate2(ctx)) {
+          return middleware2(ctx);
+        }
+      }
+      return ctx.next();
+    };
+  }
+  const predicate = typeof predicateOrPatternsOrMap === "function" ? predicateOrPatternsOrMap : patternsToPredicate(predicateOrPatternsOrMap);
+  const composedMiddleware = Array.isArray(middleware) ? compose(...middleware) : middleware;
+  return (ctx) => {
+    if (predicate(ctx)) {
+      return composedMiddleware(ctx);
+    }
+    return ctx.next();
+  };
+}
+function applyExcept(predicateOrPatterns, middleware) {
+  const matchPredicate = typeof predicateOrPatterns === "function" ? predicateOrPatterns : patternsToPredicate(predicateOrPatterns);
+  const invertedPredicate = (ctx) => !matchPredicate(ctx);
+  return applyFor(invertedPredicate, middleware);
+}
+function forStores(storeMiddleware) {
+  const composedMiddleware = Array.isArray(storeMiddleware) ? compose(...storeMiddleware) : storeMiddleware;
+  return (ctx) => {
+    if (ctx.type === "store") {
+      return composedMiddleware(ctx);
+    }
+    return ctx.next();
+  };
+}
+const DEFAULT_KEY = {};
+const cache = /* @__PURE__ */ new Map();
+function normalizeDeps(deps) {
+  return Array.isArray(deps) ? deps : [deps];
+}
+function getKeyCache(key) {
+  let keyCache = cache.get(key);
+  if (!keyCache) {
+    keyCache = /* @__PURE__ */ new WeakMap();
+    cache.set(key, keyCache);
+  }
+  return keyCache;
+}
+function trigger(keyOrFn, fnOrDepsOrOptions, depsOrFirstArg, ...restArgs) {
+  let key;
+  let fn;
+  let deps;
+  let equality;
+  let args;
+  if (typeof fnOrDepsOrOptions === "function") {
+    key = keyOrFn;
+    fn = fnOrDepsOrOptions;
+    deps = normalizeDeps(depsOrFirstArg ?? []);
+    args = restArgs;
+  } else if (fnOrDepsOrOptions !== void 0 && fnOrDepsOrOptions !== null && typeof fnOrDepsOrOptions !== "object") {
+    key = DEFAULT_KEY;
+    fn = keyOrFn;
+    deps = [fnOrDepsOrOptions];
+    args = depsOrFirstArg !== void 0 ? [depsOrFirstArg, ...restArgs] : [];
+  } else if (Array.isArray(fnOrDepsOrOptions)) {
+    key = DEFAULT_KEY;
+    fn = keyOrFn;
+    deps = fnOrDepsOrOptions;
+    args = depsOrFirstArg !== void 0 ? [depsOrFirstArg, ...restArgs] : [];
+  } else {
+    const options = fnOrDepsOrOptions ?? {};
+    key = options.key ?? DEFAULT_KEY;
+    fn = keyOrFn;
+    deps = normalizeDeps(options.deps ?? []);
+    equality = options.equality ? resolveEquality(options.equality) : void 0;
+    args = depsOrFirstArg !== void 0 ? [depsOrFirstArg, ...restArgs] : [];
+  }
+  const cacheKey = unwrapFn(fn);
+  const keyCache = getKeyCache(key);
+  const cached = keyCache.get(cacheKey);
+  const eq = equality ?? (cached == null ? void 0 : cached.equality) ?? shallowEqual;
+  if (cached && eq(cached.deps, deps)) {
+    return cached.result;
+  }
+  const result = fn(...args);
+  keyCache.set(cacheKey, { deps, result, equality });
+  return result;
+}
+trigger.clear = (key) => {
+  cache.delete(key);
+};
+trigger.clearAll = () => {
+  cache.clear();
+};
+function withMeta(factory, meta) {
+  return Object.assign(factory, {
+    meta: Array.isArray(meta) ? meta : [meta]
+  });
+}
 export {
-  A2 as AsyncFunctionError,
+  d as AsyncFunctionError,
   E as EffectRefreshError,
   H as HooksContextError,
   I as InvalidActionError,
-  c2 as LifetimeMismatchError,
-  L as LocalStoreDependencyError,
+  L as LifetimeMismatchError,
+  z as LocalStoreDependencyError,
   P as ProviderMissingError,
-  S as STORION_TYPE,
-  a2 as SetupPhaseError,
-  d2 as StoreDisposedError,
-  S2 as StorionError,
-  n as applyExcept,
-  m as applyFor,
-  b2 as batch,
-  c as container,
-  l as createResolver,
-  u as deepEqual,
-  e2 as effect,
-  q as equality,
-  o as forStores,
-  g as getKind,
-  a as is,
-  h as isAction,
-  d as isContainer,
-  f as isFocus,
-  k as isSelectorContext,
-  i as isSpec,
-  e as isStore,
-  j as isStoreContext,
-  b as isStorion,
-  z as isWrappedFn,
+  STORION_TYPE,
+  S as SetupPhaseError,
+  y as StoreDisposedError,
+  x as StorionError,
+  append,
+  applyExcept,
+  applyFor,
+  n as batch,
+  clamp,
+  container,
+  decrement,
+  v as deepEqual,
+  divide,
+  e as effect,
+  o as equality,
+  forStores,
+  increment,
+  m as is,
+  list,
+  map,
+  merge,
   m2 as meta,
+  multiply,
   p as pick,
-  t as shallowEqual,
-  s as store,
-  v as strictEqual,
-  w as trigger,
-  u2 as untrack,
-  y as unwrapFn,
-  A as withMeta,
-  x as wrapFn
+  B as pool,
+  prepend,
+  reset,
+  createResolver as resolver,
+  shallowEqual,
+  a as store,
+  h as strictEqual,
+  toggle,
+  trigger,
+  untrack,
+  withMeta
 };