@plitzi/nexus 0.31.1

package/dist/StoreContext.mjs

@@ -0,0 +1,11 @@
+import { createContext as e } from "react";
+//#region src/StoreContext.ts
+var t = e(void 0);
+t.displayName = "StoreContext";
+var n = e(void 0);
+n.displayName = "StoreRegistryContext";
+var r = (e, t) => {
+	for (let n = e; n; n = n.parent) if (n.id === t) return n.store;
+};
+//#endregion
+export { t as StoreContext, n as StoreRegistryContext, r as findStoreInRegistry };

package/dist/StoreProvider.d.ts

@@ -0,0 +1,24 @@
+import { StoreContext, StoreRegistryContext } from './StoreContext';
+import { StoreApi, StoreMiddleware } from './types';
+import { ReactNode } from 'react';
+export type StoreProviderProps<TState extends object = any> = {
+    store?: StoreApi<TState>;
+    id?: string;
+    path?: string;
+    value?: Partial<TState> | ((state: TState) => TState);
+    /**
+     * How this scope derives from the parent store:
+     * - `'snapshot'`: copy parent keys once at init; isolated thereafter (writes stay local, parent updates do
+     *   not propagate). Use for draft/diverge editors.
+     * - `'live'`: live scope chain — reads fall through to the parent, own keys shadow inherited ones, and writes
+     *   delegate to the owning scope. Parent updates propagate.
+     * - `undefined` (default): no inheritance.
+     */
+    inherit?: 'snapshot' | 'live';
+    autoSync?: boolean;
+    middlewares?: StoreMiddleware<TState>[];
+    children?: ReactNode;
+};
+declare const StoreProvider: <TState extends object = any>({ store, id, path, value, inherit, autoSync, middlewares, children }: StoreProviderProps<TState>) => import("react/jsx-runtime").JSX.Element;
+export { StoreContext, StoreRegistryContext };
+export default StoreProvider;

package/dist/StoreProvider.mjs

@@ -0,0 +1,51 @@
+import { StoreContext as e, StoreRegistryContext as t } from "./StoreContext.mjs";
+import n from "./createStore/hooks/useStoreSync.mjs";
+import r from "./createStore/index.mjs";
+import { createContext as i, useContext as a, useEffect as o, useMemo as s, useRef as c } from "react";
+import { jsx as l } from "react/jsx-runtime";
+//#region src/StoreProvider.tsx
+var u = i(void 0), d = (e) => e.cascade === !0, f = ({ store: i, id: f, path: p, value: m, inherit: h, autoSync: g = !0, middlewares: _, children: v }) => {
+	let y = a(e), b = a(u), x = a(t), S = c(void 0), C = h === "live", w = s(() => {
+		let e = h === "snapshot" && y ? y.getState() : {};
+		return typeof m == "function" ? m(e) : {
+			...e,
+			...m
+		};
+	}, [
+		h,
+		y,
+		m
+	]), T = _ ?? [], E = b ? [...b, ...T] : T, D = s(() => [...b ?? [], ...T.filter(d)], [b, _]);
+	S.current ||= i ?? r(() => w, {
+		id: f,
+		parent: C ? y : void 0,
+		middlewares: E.length > 0 ? E : void 0
+	});
+	let O = s(() => f ? {
+		id: f,
+		store: S.current,
+		parent: x
+	} : x, [f, x]);
+	c(!1), o(() => {}, [f, x]), o(() => (C && !i && S.current?.reconnect?.(), () => {
+		C && !i && S.current?.destroy?.();
+	}), [C, i]);
+	let k = !!m && g;
+	return n(p, p ? m : w, {
+		enabled: k && !!p,
+		store: S.current
+	}), n(void 0, w, {
+		enabled: k && !p,
+		store: S.current
+	}), /* @__PURE__ */ l(u, {
+		value: D.length > 0 ? D : void 0,
+		children: /* @__PURE__ */ l(t, {
+			value: O,
+			children: /* @__PURE__ */ l(e, {
+				value: S.current,
+				children: v
+			})
+		})
+	});
+};
+//#endregion
+export { f as default };

package/dist/async/createAsync.d.ts

@@ -0,0 +1,19 @@
+import { PathOf, PathValue, StoreApi } from '../types';
+export type AsyncStatus = 'idle' | 'pending' | 'success' | 'error';
+export type AsyncSnapshot<T> = {
+    status: AsyncStatus;
+    data: T | undefined;
+    error: unknown;
+    isLoading: boolean;
+};
+export type AsyncResource<T, Args extends readonly unknown[]> = {
+    get: () => AsyncSnapshot<T>;
+    run: (...args: Args) => Promise<T>;
+    subscribe: (listener: () => void) => () => void;
+    suspend: () => Promise<void> | undefined;
+    destroy: () => void;
+};
+export type AsyncOptions<Args extends readonly unknown[]> = {
+    immediate?: Args;
+};
+export declare function createAsync<TState extends object, P extends PathOf<TState>, Args extends readonly unknown[]>(store: StoreApi<TState>, path: P, fetcher: (...args: Args) => Promise<PathValue<TState, P>>, options?: AsyncOptions<Args>): AsyncResource<PathValue<TState, P>, Args>;

package/dist/async/createAsync.mjs

@@ -0,0 +1,29 @@
+import { createObservable as e } from "../helpers/createObservable.mjs";
+//#region src/async/createAsync.ts
+function t(t, n, r, i = {}) {
+	let a = "idle", o, s, c, l = e(() => ({
+		status: a,
+		data: t.getPath(n),
+		error: o,
+		isLoading: a === "pending"
+	})), u = () => {
+		l.invalidate(), l.notify();
+	}, d = l.get, f = (...e) => {
+		a = "pending", o = void 0;
+		let i = Promise.resolve().then(() => r(...e));
+		return s = i, c = i.then(() => void 0, () => void 0), u(), i.then((e) => (i === s && (s = void 0, c = void 0, a = "success", t.setState(n, e), u()), e), (e) => {
+			throw i === s && (s = void 0, c = void 0, a = "error", o = e, u()), e;
+		});
+	}, p = t.subscribePath(n, u);
+	return i.immediate && f(...i.immediate).catch(() => void 0), {
+		get: d,
+		run: f,
+		subscribe: l.subscribe,
+		suspend: () => c,
+		destroy: () => {
+			p(), l.destroy();
+		}
+	};
+}
+//#endregion
+export { t as createAsync };

package/dist/async/hooks/useAsync.d.ts

@@ -0,0 +1,2 @@
+import { AsyncResource, AsyncSnapshot } from '../createAsync';
+export declare function useAsync<T, Args extends readonly unknown[]>(resource: AsyncResource<T, Args>): AsyncSnapshot<T>;

package/dist/async/hooks/useAsync.mjs

@@ -0,0 +1,7 @@
+import { useSyncExternalStore as e } from "react";
+//#region src/async/hooks/useAsync.ts
+function t(t) {
+	return e(t.subscribe, t.get, t.get);
+}
+//#endregion
+export { t as useAsync };

package/dist/async/hooks/useAsyncValue.d.ts

@@ -0,0 +1,2 @@
+import { AsyncResource } from '../createAsync';
+export declare function useAsyncValue<T, Args extends readonly unknown[]>(resource: AsyncResource<T, Args>): T;

package/dist/async/hooks/useAsyncValue.mjs

@@ -0,0 +1,13 @@
+import { useAsync as e } from "./useAsync.mjs";
+//#region src/async/hooks/useAsyncValue.ts
+function t(t) {
+	let n = e(t);
+	if (n.status === "error") throw n.error;
+	if (n.status === "pending") {
+		let e = t.suspend();
+		if (e) throw e;
+	}
+	return n.data;
+}
+//#endregion
+export { t as useAsyncValue };

package/dist/async/index.d.ts

@@ -0,0 +1,4 @@
+export { createAsync } from './createAsync';
+export { useAsync } from './hooks/useAsync';
+export { useAsyncValue } from './hooks/useAsyncValue';
+export type { AsyncOptions, AsyncResource, AsyncSnapshot, AsyncStatus } from './createAsync';

package/dist/async/index.mjs

@@ -0,0 +1,4 @@
+import { createAsync as e } from "./createAsync.mjs";
+import { useAsync as t } from "./hooks/useAsync.mjs";
+import { useAsyncValue as n } from "./hooks/useAsyncValue.mjs";
+export { e as createAsync, t as useAsync, n as useAsyncValue };

package/dist/createStore/createStore.d.ts

@@ -0,0 +1,90 @@
+import { GetState, GetterTuple, GetValueFn, GetValueFromBaseFn, GetValueFromBaseWithDefaultFn, MultiPathReturn, PathOf, PathOrFn, PathOrFnSetters, PathOrFnValue, PathOrFnValues, PathSetters, PathSetter, PathValue, PathValues, SetFromBaseFn, SetState, SetStateFn, StoreApi, StoreMiddleware, UseStoreGetterOptions, UseStoreMultiOptions, UseStoreOptions, UseStoreSetterOptions, UseStoreSyncMultiOptions, UseStoreSyncOptions } from '../types';
+declare function createStore<TState extends object>(initializer: Partial<TState> | ((set: SetState<TState>, get: GetState<TState>) => Partial<TState>), storeOptions?: {
+    id?: string;
+    parent?: StoreApi<TState>;
+    middlewares?: StoreMiddleware<TState>[];
+}): StoreApi<TState>;
+export declare const createStoreHook: <TState extends object>() => {
+    useStore: {
+        (options?: UseStoreOptions<TState, TState>): [TState, StoreApi<TState>["setState"]];
+        <P extends PathOf<TState>>(path: P, options: Omit<UseStoreOptions<PathValue<TState, P>, TState>, "defaultValue"> & {
+            defaultValue: undefined;
+            transformer?: never;
+        }): [PathValue<TState, P> | undefined, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
+        <P extends PathOf<TState>>(path: P, options?: UseStoreOptions<PathValue<TState, P>, TState> & {
+            defaultValue?: never;
+            transformer?: never;
+        }): [PathValue<TState, P>, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
+        <P extends PathOf<TState>, D>(path: P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
+            defaultValue: D;
+            transformer?: never;
+        }): [NonNullable<PathValue<TState, P>> | D, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
+        <P extends PathOf<TState>, TResult>(path: P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
+            transformer: (value: PathValue<TState, P>) => TResult;
+        }): [TResult, (value: PathValue<TState, P> | ((prev: PathValue<TState, P>) => PathValue<TState, P>)) => void];
+        <P extends PathOf<TState>>(pathFn: (state: TState) => P, options: Omit<UseStoreOptions<PathValue<TState, P>, TState>, "defaultValue"> & {
+            defaultValue: undefined;
+            transformer?: never;
+        }): [PathValue<TState, P> | undefined, PathSetter<TState, P>];
+        <P extends PathOf<TState>>(pathFn: (state: TState) => P, options?: UseStoreOptions<PathValue<TState, P>, TState> & {
+            defaultValue?: never;
+            transformer?: never;
+        }): [PathValue<TState, P>, PathSetter<TState, P>];
+        <P extends PathOf<TState>, D_1>(pathFn: (state: TState) => P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
+            defaultValue: D_1;
+            transformer?: never;
+        }): [NonNullable<PathValue<TState, P>> | D_1, PathSetter<TState, P>];
+        <P extends PathOf<TState>, TResult_1>(pathFn: (state: TState) => P, options: UseStoreOptions<PathValue<TState, P>, TState> & {
+            transformer: (value: PathValue<TState, P>) => TResult_1;
+        }): [TResult_1, PathSetter<TState, P>];
+        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options?: Omit<UseStoreMultiOptions<TState, Paths>, "defaultValue" | "transformer">): MultiPathReturn<TState, Paths>;
+        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, options: UseStoreMultiOptions<TState, Paths> & {
+            defaultValue: undefined;
+            transformer?: never;
+        }): MultiPathReturn<TState, Paths, undefined>;
+        <const Paths extends ReadonlyArray<PathOf<TState>>, const TDefaultValue extends readonly (PathValue<TState, Paths[number]> | undefined)[]>(paths: Paths, options: UseStoreMultiOptions<TState, Paths, TDefaultValue> & {
+            defaultValue: TDefaultValue;
+            transformer?: never;
+        }): MultiPathReturn<TState, Paths, TDefaultValue>;
+        <const Paths extends ReadonlyArray<PathOf<TState>>, TDefaultValue_1 extends PathValue<TState, Paths[number]>>(paths: Paths, options: UseStoreMultiOptions<TState, Paths, TDefaultValue_1> & {
+            defaultValue: TDefaultValue_1;
+            transformer?: never;
+        }): MultiPathReturn<TState, Paths, TDefaultValue_1>;
+        <const Paths extends ReadonlyArray<PathOf<TState>>, TResult_2>(paths: Paths, options: UseStoreMultiOptions<TState, Paths> & {
+            transformer: (values: PathValues<TState, Paths>) => TResult_2;
+        }): [TResult_2, ...PathSetters<TState, Paths>];
+        <const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options?: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
+            transformer?: never;
+        }): [PathOrFnValues<TState, Entries>, ...PathOrFnSetters<TState, Entries>];
+        <const Entries extends ReadonlyArray<PathOrFn<TState>>>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
+            defaultValue: undefined;
+            transformer?: never;
+        }): [{ [I in keyof Entries]: PathOrFnValue<TState, Entries[I]> | undefined; }, ...PathOrFnSetters<TState, Entries>];
+        <const Entries extends ReadonlyArray<PathOrFn<TState>>, const TDefaultValue_2 extends readonly unknown[]>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
+            defaultValue: TDefaultValue_2;
+            transformer?: never;
+        }): [{ [I in keyof Entries]: I extends keyof TDefaultValue_2 ? TDefaultValue_2[I] extends undefined ? PathOrFnValue<TState, Entries[I]> | undefined : NonNullable<PathOrFnValue<TState, Entries[I]>> | TDefaultValue_2[I] : PathOrFnValue<TState, Entries[I]>; }, ...PathOrFnSetters<TState, Entries>];
+        <const Entries extends ReadonlyArray<PathOrFn<TState>>, TResult_3>(paths: Entries, options: Omit<UseStoreMultiOptions<TState, any>, "defaultValue" | "transformer"> & {
+            transformer: (values: PathOrFnValues<TState, Entries>) => TResult_3;
+        }): [TResult_3, ...PathOrFnSetters<TState, Entries>];
+    };
+    useStoreSync: {
+        (path: undefined, value: TState | Partial<TState>, options?: UseStoreSyncOptions<TState, TState>): void;
+        <P extends PathOf<TState>>(path: P | ((state: TState) => P), value: PathValue<TState, P>, options?: UseStoreSyncOptions<PathValue<TState, P>, TState>): void;
+        <const Paths extends ReadonlyArray<PathOf<TState>>>(paths: Paths, values: PathValues<TState, Paths>, options?: UseStoreSyncMultiOptions<TState>): void;
+        (paths: ReadonlyArray<PathOrFn<TState>>, values: readonly unknown[], options?: UseStoreSyncMultiOptions<TState>): void;
+    };
+    useStoreGetter: {
+        (options?: UseStoreGetterOptions<TState>): GetValueFn<TState>;
+        <P extends PathOf<TState>>(basePath: P, options?: UseStoreGetterOptions<TState>): GetValueFromBaseFn<PathValue<TState, P>>;
+        <P extends PathOf<TState>, D_2>(basePath: P, options: UseStoreGetterOptions<TState, D_2> & {
+            defaultValue: D_2;
+        }): GetValueFromBaseWithDefaultFn<PathValue<TState, P>, D_2>;
+        <const Entries extends ReadonlyArray<PathOf<TState> | ((state: TState) => unknown)>>(entries: Entries, options?: UseStoreGetterOptions<TState>): GetterTuple<TState, Entries>;
+    };
+    useStoreSetter: {
+        (options?: UseStoreSetterOptions<TState>): SetStateFn<TState>;
+        <P extends PathOf<TState>>(basePath: P, options?: UseStoreSetterOptions<TState>): SetFromBaseFn<PathValue<TState, P>>;
+    };
+};
+export default createStore;

package/dist/createStore/createStore.mjs

@@ -0,0 +1,104 @@
+import { createChainReads as e } from "./helpers/createChainReads.mjs";
+import { createSetState as t } from "./helpers/createSetState.mjs";
+import { forwardParentChanges as n } from "./helpers/forwardParentChanges.mjs";
+import r from "./helpers/Subscribers.mjs";
+import i from "./helpers/PathTrie.mjs";
+import "./helpers/scopeCollisions.mjs";
+import a from "./hooks/useStore.mjs";
+import o from "./hooks/useStoreGetter.mjs";
+import s from "./hooks/useStoreSetter.mjs";
+import c from "./hooks/useStoreSync.mjs";
+//#region src/createStore/createStore.ts
+var l = 0;
+function u(a, o) {
+	let s = {}, c, u = new r(), d = new r(), f = new i(), p = new r(), m = () => {
+		p.forEach((e) => e());
+	}, h = [], g = [], _ = o?.parent;
+	++l;
+	let v = (e, t, n) => {
+		if (g.length === 0) throw e;
+		let r = {
+			error: e,
+			phase: t,
+			path: n
+		};
+		for (let e = 0, t = g.length; e < t; e++) g[e](r);
+	}, y = () => s, b = () => c ??= { ...s }, { getState: x, getPath: S, invalidate: C, setActive: w, getMergeCount: T } = e(y, b, _);
+	_ && w(!1);
+	let { setState: E, batch: D } = t({
+		getOwnState: y,
+		getOwnSnapshot: b,
+		setOwnState: (e) => {
+			s = e, c = void 0, C();
+		},
+		mutateOwnKey: (e, t) => {
+			s[e] = t, C(), c = void 0;
+		},
+		parent: _,
+		listeners: u,
+		pathListeners: f,
+		changeListeners: d,
+		interceptors: h,
+		reportError: v,
+		invalidateDescendants: m,
+		onDelegateToParent: void 0
+	}), O = () => {
+		C(), m();
+	}, k, A, j = !1, M = () => u.length > 0 || f.size > 0 || d.length > 0, N = () => {
+		k || !_ || (C(), w(!0), k = n(_, u, f, d, x, v, C), A = _.subscribeInvalidate?.(O), d.length > 0 && k.seedBaseline());
+	}, P = () => {
+		k && (k.unsubscribe(), k = void 0, A?.(), A = void 0, w(!1));
+	}, F = () => {
+		_ && (!j && M() ? N() : P());
+	}, I = (e) => (F(), () => {
+		e(), F();
+	}), L = (e) => I(u.add(e)), R = (e, t) => I(f.add(e, t)), z = (e) => {
+		let t = I(d.add(e));
+		return k?.seedBaseline(), t;
+	};
+	s = typeof a == "function" ? a(E, x) : a;
+	let B = {
+		id: o?.id,
+		getState: x,
+		getPath: S,
+		setState: E,
+		batch: D,
+		subscribe: L,
+		subscribePath: R,
+		subscribeChange: z,
+		destroy: () => {
+			j = !0, P(), u.clear(), f.clear(), d.clear(), p.clear();
+		},
+		reconnect: () => {
+			j = !1, F();
+		},
+		subscribeInvalidate: (e) => p.add(e)
+	};
+	if (o?.middlewares) for (let e of o.middlewares) {
+		let t = e(B);
+		t?.beforeChange && h.push(t.beforeChange), t?.onChange && z(t.onChange), t?.onError && g.push(t.onError);
+	}
+	return B;
+}
+var d = () => {
+	function e(e, t) {
+		return a(e, t);
+	}
+	function t(e, t, n) {
+		c(e, t, n);
+	}
+	function n(e, t) {
+		return o(e, t);
+	}
+	function r(e, t) {
+		return s(e, t);
+	}
+	return {
+		useStore: e,
+		useStoreSync: t,
+		useStoreGetter: n,
+		useStoreSetter: r
+	};
+};
+//#endregion
+export { d as createStoreHook, u as default };

package/dist/createStore/helpers/PathTrie.d.ts

@@ -0,0 +1,13 @@
+import { default as Subscribers } from './Subscribers';
+import { Listener, Path } from '../../types';
+declare class PathTrie {
+    readonly direct: Map<string, Subscribers<Listener>>;
+    private readonly descendants;
+    size: number;
+    add(path: string, listener: Listener): () => void;
+    private remove;
+    getDescendants(path: string): Set<string> | undefined;
+    forEachAffected(changedPath: Path | undefined, cb: (listener: Listener) => void, onError?: (error: unknown) => void): void;
+    clear(): void;
+}
+export default PathTrie;

package/dist/createStore/helpers/PathTrie.mjs

@@ -0,0 +1,43 @@
+import e from "../../helpers/parsePath.mjs";
+import t from "./Subscribers.mjs";
+//#region src/createStore/helpers/PathTrie.ts
+var n = (e, t, n) => {
+	let r = "";
+	for (let i = 0; i < t; i++) r = r ? `${r}.${e[i]}` : e[i], n(r);
+}, r = class {
+	direct = /* @__PURE__ */ new Map();
+	descendants = /* @__PURE__ */ new Map();
+	size = 0;
+	add(r, i) {
+		let a = this.direct.get(r), o = e(r);
+		return a || (a = new t(), this.direct.set(r, a), this.size++, n(o, o.length - 1, (e) => {
+			let t = this.descendants.get(e);
+			t || (t = /* @__PURE__ */ new Set(), this.descendants.set(e, t)), t.add(r);
+		})), a.add(i), () => this.remove(r, a, i, o);
+	}
+	remove(e, t, r, i) {
+		this.direct.get(e) === t && (t.remove(r), !(t.length > 0) && (this.direct.delete(e), this.size--, n(i, i.length - 1, (t) => {
+			let n = this.descendants.get(t);
+			n && (n.delete(e), n.size === 0 && this.descendants.delete(t));
+		})));
+	}
+	getDescendants(e) {
+		return this.descendants.get(e);
+	}
+	forEachAffected(t, r, i) {
+		let a = (e) => {
+			e && e.forEach(r, i);
+		};
+		if (typeof t != "string") {
+			this.direct.forEach(a);
+			return;
+		}
+		let o = e(t);
+		n(o, o.length, (e) => a(this.direct.get(e))), this.descendants.get(t)?.forEach((e) => a(this.direct.get(e)));
+	}
+	clear() {
+		this.direct.clear(), this.descendants.clear(), this.size = 0;
+	}
+};
+//#endregion
+export { r as default };

package/dist/createStore/helpers/Subscribers.d.ts

@@ -0,0 +1,15 @@
+export type AnyListener = (...args: never[]) => void;
+declare class Subscribers<F extends AnyListener> {
+    readonly items: F[];
+    private notifying;
+    private dead;
+    get length(): number;
+    add(listener: F): () => void;
+    remove(listener: F): void;
+    begin(): void;
+    end(): void;
+    forEach(cb: (listener: F) => void, onError?: (error: unknown) => void): void;
+    clear(): void;
+    private compact;
+}
+export default Subscribers;

package/dist/createStore/helpers/Subscribers.mjs

@@ -0,0 +1,59 @@
+//#region src/createStore/helpers/Subscribers.ts
+var e = () => {}, t = class {
+	items = [];
+	notifying = 0;
+	dead = 0;
+	get length() {
+		return this.items.length - this.dead;
+	}
+	add(e) {
+		return this.items.push(e), () => this.remove(e);
+	}
+	remove(t) {
+		let n = this.items.indexOf(t);
+		if (n === -1) return;
+		if (this.notifying > 0) {
+			this.items[n] = e, this.dead++;
+			return;
+		}
+		let r = this.items.pop();
+		n < this.items.length && (this.items[n] = r);
+	}
+	begin() {
+		this.notifying++;
+	}
+	end() {
+		--this.notifying === 0 && this.dead > 0 && this.compact();
+	}
+	forEach(e, t) {
+		this.begin();
+		try {
+			let { items: n } = this, r = n.length, i = 0, a, o = !1;
+			for (; i < r;) try {
+				for (; i < r; i++) e(n[i]);
+			} catch (e) {
+				o || (o = !0, a = e), i++;
+			}
+			if (o) if (t) t(a);
+			else throw a;
+		} finally {
+			this.end();
+		}
+	}
+	clear() {
+		if (this.notifying > 0) {
+			let { items: t } = this;
+			for (let n = 0, r = t.length; n < r; n++) t[n] = e;
+			this.dead = t.length;
+			return;
+		}
+		this.items.length = 0, this.dead = 0;
+	}
+	compact() {
+		let { items: t } = this, n = 0;
+		for (let r = 0; r < t.length; r++) t[r] !== e && (t[n++] = t[r]);
+		t.length = n, this.dead = 0;
+	}
+};
+//#endregion
+export { t as default };

package/dist/createStore/helpers/createChainReads.d.ts

@@ -0,0 +1,10 @@
+import { GetState, PathOf, PathValue, StoreApi } from '../../types';
+export type GetPath<TState extends object> = <P extends PathOf<TState>>(path: P) => PathValue<TState, P> | undefined;
+export type ChainReads<TState extends object> = {
+    getState: GetState<TState>;
+    getPath: GetPath<TState>;
+    invalidate: () => void;
+    setActive: (active: boolean) => void;
+    getMergeCount: () => number;
+};
+export declare function createChainReads<TState extends object>(getOwnState: () => TState, getOwnSnapshot: () => TState, parent: StoreApi<TState> | undefined): ChainReads<TState>;

package/dist/createStore/helpers/createChainReads.mjs

@@ -0,0 +1,37 @@
+import { deepMerge as e, isPlainObject as t } from "./deepMerge.mjs";
+import n from "../../helpers/getByPath.mjs";
+//#region src/createStore/helpers/createChainReads.ts
+function r(r, i, a) {
+	if (!a) return {
+		getState: i,
+		getPath: (e) => n(r(), e),
+		invalidate: () => {},
+		setActive: () => {},
+		getMergeCount: () => 0
+	};
+	let o = a, s = !0, c = !0, l = !1, u, d = 0, f = /* @__PURE__ */ new Map(), p = () => (d++, e(o.getState(), i())), m = () => s ? ((c || u === void 0) && (u = p(), c = !1), u) : p(), h = (e) => {
+		let i = n(r(), e);
+		if (i === void 0) return o.getPath(e);
+		let a = o.getPath(e);
+		return a === void 0 || !t(i) || !t(a) ? i : n(m(), e);
+	};
+	return {
+		getState: m,
+		getPath: (e) => {
+			if (!s) return h(e);
+			if (l) f.clear(), l = !1;
+			else if (f.has(e)) return f.get(e);
+			let t = h(e);
+			return f.set(e, t), t;
+		},
+		invalidate: () => {
+			c = !0, l = !0;
+		},
+		setActive: (e) => {
+			s = e, e || (f.clear(), u = void 0, c = !0, l = !1);
+		},
+		getMergeCount: () => d
+	};
+}
+//#endregion
+export { r as createChainReads };

package/dist/createStore/helpers/createSetState.d.ts

@@ -0,0 +1,22 @@
+import { default as PathTrie } from './PathTrie';
+import { default as Subscribers } from './Subscribers';
+import { ChangeListener, Listener, SetState, StoreApi, StoreErrorReporter, WriteInterceptor } from '../../types';
+export type SetStateDeps<TState extends object> = {
+    getOwnState: () => TState;
+    getOwnSnapshot: () => TState;
+    setOwnState: (next: TState) => void;
+    mutateOwnKey: (key: string, value: unknown) => void;
+    parent: StoreApi<TState> | undefined;
+    listeners: Subscribers<Listener>;
+    changeListeners: Subscribers<ChangeListener<TState>>;
+    pathListeners: PathTrie;
+    interceptors: WriteInterceptor<TState>[];
+    reportError: StoreErrorReporter<TState>;
+    invalidateDescendants: () => void;
+    onDelegateToParent?: (path: string) => void;
+};
+export type SetStateApi<TState extends object> = {
+    setState: SetState<TState>;
+    batch: <R>(fn: () => R) => R;
+};
+export declare function createSetState<TState extends object>(deps: SetStateDeps<TState>): SetStateApi<TState>;