@codebelt/classy-store 0.0.1 → 0.0.2

package/dist/index.cjs

@@ -1,9 +1,7 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-const require_snapshot = require('./snapshot-TbHIUjvP.cjs');
-let proxy_compare = require("proxy-compare");
-let react = require("react");
+const require_snapshot = require('./snapshot-CR8nA2Ob.cjs');
 
-//#region src/collections.ts
+//#region src/collections/collections.ts
 /**
 * A Map-like class backed by a plain array so `store()` can proxy mutations.
 *
@@ -169,66 +167,36 @@ function reactiveSet(initial) {
 }
 
 //#endregion
-//#region src/useStore.ts
-function useStore(proxyStore, selector, isEqual) {
-	require_snapshot.getInternal(proxyStore);
-	const subscribe$1 = (0, react.useCallback)((onStoreChange) => require_snapshot.subscribe(proxyStore, onStoreChange), [proxyStore]);
-	const snapRef = (0, react.useRef)(void 0);
-	const resultRef = (0, react.useRef)(void 0);
-	const affected = (0, react.useRef)(/* @__PURE__ */ new WeakMap()).current;
-	const proxyCache = (0, react.useRef)(/* @__PURE__ */ new WeakMap()).current;
-	const prevSnapRef = (0, react.useRef)(void 0);
-	const wrappedRef = (0, react.useRef)(void 0);
-	const getSnapshot = () => selector ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) : getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef);
-	return (0, react.useSyncExternalStore)(subscribe$1, getSnapshot, getSnapshot);
-}
+//#region src/utils/equality/equality.ts
 /**
-* `getSnapshot` implementation for selector mode.
-*
-* Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise
-* runs the selector against the new snapshot and compares the result to the
-* previous one via `Object.is` (or a custom `isEqual`). Returns the previous
-* result reference when equal, preventing unnecessary React re-renders.
+* Shallow-equal comparison for objects and arrays.
+* Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.
 *
-* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
+* - Primitives compared with `Object.is`.
+* - Arrays: length + element-wise `Object.is`.
+* - Objects: key count + value-wise `Object.is`.
 */
-function getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) {
-	const nextSnap = require_snapshot.snapshot(proxyStore);
-	if (snapRef.current === nextSnap && resultRef.current !== void 0) return resultRef.current;
-	const nextResult = selector(nextSnap);
-	snapRef.current = nextSnap;
-	if (resultRef.current !== void 0 && (isEqual ? isEqual(resultRef.current, nextResult) : Object.is(resultRef.current, nextResult))) return resultRef.current;
-	resultRef.current = nextResult;
-	return nextResult;
-}
-/**
-* `getSnapshot` implementation for auto-tracked (selectorless) mode.
-*
-* Uses `proxy-compare` to diff only the properties the component actually read.
-* If the snapshot reference is the same, returns the cached tracking proxy.
-* If the snapshot changed but no tracked property differs (`isChanged` returns
-* false), also returns the cached proxy -- avoiding re-render. Only when a
-* relevant property changed does it create a new `createProxy` wrapper.
-*
-* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
-*/
-function getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef) {
-	const nextSnap = require_snapshot.snapshot(proxyStore);
-	if (prevSnapRef.current === nextSnap) return wrappedRef.current;
-	if (prevSnapRef.current !== void 0 && !(0, proxy_compare.isChanged)(prevSnapRef.current, nextSnap, affected)) return wrappedRef.current;
-	prevSnapRef.current = nextSnap;
-	const wrapped = (0, proxy_compare.createProxy)(nextSnap, affected, proxyCache);
-	wrappedRef.current = wrapped;
-	return wrapped;
+function shallowEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+		return true;
+	}
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) if (!Object.hasOwn(b, key) || !Object.is(a[key], b[key])) return false;
+	return true;
 }
 
 //#endregion
 exports.getVersion = require_snapshot.getVersion;
 exports.reactiveMap = reactiveMap;
 exports.reactiveSet = reactiveSet;
-exports.shallowEqual = require_snapshot.shallowEqual;
+exports.shallowEqual = shallowEqual;
 exports.snapshot = require_snapshot.snapshot;
 exports.store = require_snapshot.store;
 exports.subscribe = require_snapshot.subscribe;
-exports.useStore = useStore;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","names":["PROXYABLE","subscribe","coreSubscribe","snapshot"],"sources":["../src/collections.ts","../src/useStore.ts"],"sourcesContent":["import {PROXYABLE} from './utils';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useSyncExternalStore} from 'react';\nimport {subscribe as coreSubscribe, getInternal} from './core';\nimport {snapshot} from './snapshot';\nimport type {Snapshot} from './types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.cjs","names":["PROXYABLE"],"sources":["../src/collections/collections.ts","../src/utils/equality/equality.ts"],"sourcesContent":["import {PROXYABLE} from '../utils/internal/internal';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","/**\n * Shallow-equal comparison for objects and arrays.\n * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.\n *\n * - Primitives compared with `Object.is`.\n * - Arrays: length + element-wise `Object.is`.\n * - Objects: key count + value-wise `Object.is`.\n */\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  if (Object.is(a, b)) return true;\n  if (\n    typeof a !== 'object' ||\n    a === null ||\n    typeof b !== 'object' ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!Object.is(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) return false;\n\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !Object.is(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}

package/dist/index.d.cts

@@ -1,21 +1,14 @@
-//#region src/utils.d.ts
+import { t as Snapshot } from "./types-B6RZUB86.cjs";
+
+//#region src/utils/internal/internal.d.ts
 /**
  * Symbol that class instances can use to opt-in to deep proxying.
  * Classes with `static [PROXYABLE] = true` will be wrapped by the store proxy
  * just like plain objects, enabling nested reactivity.
  */
 declare const PROXYABLE: unique symbol;
-/**
- * Shallow-equal comparison for objects and arrays.
- * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.
- *
- * - Primitives compared with `Object.is`.
- * - Arrays: length + element-wise `Object.is`.
- * - Objects: key count + value-wise `Object.is`.
- */
-declare function shallowEqual<T>(a: T, b: T): boolean;
 //#endregion
-//#region src/collections.d.ts
+//#region src/collections/collections.d.ts
 /**
  * A Map-like class backed by a plain array so `store()` can proxy mutations.
  *
@@ -113,32 +106,7 @@ declare function reactiveMap<K, V>(initial?: Iterable<[K, V]>): ReactiveMap<K, V
  */
 declare function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T>;
 //#endregion
-//#region src/types.d.ts
-/**
- * Primitive types that should not be proxied or snapshot-cloned.
- * Used by `Snapshot<T>` to identify leaf types that pass through unchanged.
- */
-type Primitive = string | number | boolean | null | undefined | symbol | bigint;
-/**
- * Function type shorthand.
- * Functions are treated as snapshot leaves -- they pass through unchanged
- * because freezing or cloning them would break callable references.
- */
-type AnyFunction = (...args: unknown[]) => unknown;
-/**
- * Types that `snapshot()` returns as-is (no deep clone or freeze).
- * These are either already immutable-ish (Date, RegExp), use internal slots
- * that proxies can't intercept (Map, Set, WeakMap, WeakSet), or can't be
- * meaningfully frozen (functions, Promises, Errors).
- */
-type SnapshotLeaf = Primitive | AnyFunction | Date | RegExp | Error | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | Promise<unknown>;
-/**
- * Recursively converts an object type to a deeply readonly version.
- * Leaf types (primitives, Date, Map, etc.) pass through unchanged.
- */
-type Snapshot<T> = T extends SnapshotLeaf ? T : T extends Array<infer U> ? ReadonlyArray<Snapshot<U>> : T extends object ? { readonly [K in keyof T]: Snapshot<T[K]> } : T;
-//#endregion
-//#region src/core.d.ts
+//#region src/core/core.d.ts
 /**
  * Wraps a class instance in a reactive proxy.
  *
@@ -170,7 +138,7 @@ declare function subscribe(proxy: object, callback: () => void): () => void;
  */
 declare function getVersion(proxy: object): number;
 //#endregion
-//#region src/snapshot.d.ts
+//#region src/snapshot/snapshot.d.ts
 /**
  * Creates an immutable, deeply-frozen snapshot of the store proxy's current state.
  *
@@ -189,27 +157,16 @@ declare function getVersion(proxy: object): number;
  */
 declare function snapshot<T extends object>(proxyStore: T): Snapshot<T>;
 //#endregion
-//#region src/useStore.d.ts
-/**
- * Subscribe to a store proxy with an explicit selector.
- *
- * Re-renders only when the selected value changes (compared via `Object.is`
- * by default, or a custom `isEqual`).
- *
- * @param proxyStore - A reactive proxy created by `store()`.
- * @param selector  - Picks data from the immutable snapshot.
- * @param isEqual   - Optional custom equality function (default: `Object.is`).
- */
-declare function useStore<T extends object, S>(proxyStore: T, selector: (snap: Snapshot<T>) => S, isEqual?: (a: S, b: S) => boolean): S;
+//#region src/utils/equality/equality.d.ts
 /**
- * Subscribe to a store proxy **without** a selector (auto-tracked mode).
- *
- * Returns a `proxy-compare` tracking proxy over the immutable snapshot.
- * The component only re-renders when a property it actually read changes.
+ * Shallow-equal comparison for objects and arrays.
+ * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.
  *
- * @param proxyStore - A reactive proxy created by `store()`.
+ * - Primitives compared with `Object.is`.
+ * - Arrays: length + element-wise `Object.is`.
+ * - Objects: key count + value-wise `Object.is`.
  */
-declare function useStore<T extends object>(proxyStore: T): Snapshot<T>;
+declare function shallowEqual<T>(a: T, b: T): boolean;
 //#endregion
-export { type ReactiveMap, type ReactiveSet, type Snapshot, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe, useStore };
+export { type ReactiveMap, type ReactiveSet, type Snapshot, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/utils.ts","../src/collections.ts","../src/types.ts","../src/core.ts","../src/snapshot.ts","../src/useStore.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/utils/internal/internal.ts","../src/collections/collections.ts","../src/core/core.ts","../src/snapshot/snapshot.ts","../src/utils/equality/equality.ts"],"mappings":";;;;;;AAOA;;cAAa,SAAA;;;;;AAAb;;;;;;;;ACUA;;;cAAa,WAAA;EAAA,QACH,SAAA;EAGM;EAAd,QAAA,GAAW,CAAA,EAAG,CAAA;EAGqB;cAAvB,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA;EAmB1B;EAAA,IALL,IAAA,CAAA;EAWK;EANT,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;EAWM;EALnB,GAAA,CAAI,GAAA,EAAK,CAAA;EA6BgB;EAxBzB,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;EA6BQ;EAlB3B,MAAA,CAAO,GAAA,EAAK,CAAA;EAuBiB;EAf7B,KAAA,CAAA;EAeW;EAVX,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EAeS;EAVlC,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EAU8B;EALzD,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAYO;EAPvC,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA,EAAG,CAAA;EAOpC;EAAA,CAApB,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;AAAA;;;;;;;;;;;;;;cAoB/B,WAAA;EAAA,QACH,SAAA;EA9EJ;EAiFJ,MAAA,EAAQ,CAAA;EA3ER;cA8EY,OAAA,GAAU,QAAA,CAAS,CAAA;EA9E3B;EAAA,IAyFA,IAAA,CAAA;EApFK;EAyFT,GAAA,CAAI,KAAA,EAAO,CAAA;EAzFQ;EA8FnB,GAAA,CAAI,KAAA,EAAO,CAAA;EAnFX;EA2FA,MAAA,CAAO,KAAA,EAAO,CAAA;EA3FP;EAmGP,KAAA,CAAA;EAtFA;EA2FA,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EA3FA;EAgGzB,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EA3FjB;EAgGV,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EA3FhC;EAgGA,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA;EAhGzB;EAAA,CAuG5B,MAAA,CAAO,QAAA,KAAa,gBAAA,CAAiB,CAAA;AAAA;;;;;;;iBAaxB,WAAA,MAAA,CACd,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA,KACtB,WAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;iBAUF,WAAA,GAAA,CAAe,OAAA,GAAU,QAAA,CAAS,CAAA,IAAK,WAAA,CAAY,CAAA;;;;AAvMnE;;;;;;;;;;;iBCmRgB,KAAA,kBAAA,CAAwB,QAAA,EAAU,CAAA,GAAI,CAAA;;;;;;;;;iBAYtC,SAAA,CAAU,KAAA,UAAe,QAAA;;;;;;;;iBAkBzB,UAAA,CAAW,KAAA;;;;;AF3T3B;;;;;;;;ACUA;;;;;;iBEwUgB,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;AHlVpE;;;;;iBICgB,YAAA,GAAA,CAAgB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA"}

package/dist/index.d.mts

@@ -1,21 +1,14 @@
-//#region src/utils.d.ts
+import { t as Snapshot } from "./types-vWYkF3tH.mjs";
+
+//#region src/utils/internal/internal.d.ts
 /**
  * Symbol that class instances can use to opt-in to deep proxying.
  * Classes with `static [PROXYABLE] = true` will be wrapped by the store proxy
  * just like plain objects, enabling nested reactivity.
  */
 declare const PROXYABLE: unique symbol;
-/**
- * Shallow-equal comparison for objects and arrays.
- * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.
- *
- * - Primitives compared with `Object.is`.
- * - Arrays: length + element-wise `Object.is`.
- * - Objects: key count + value-wise `Object.is`.
- */
-declare function shallowEqual<T>(a: T, b: T): boolean;
 //#endregion
-//#region src/collections.d.ts
+//#region src/collections/collections.d.ts
 /**
  * A Map-like class backed by a plain array so `store()` can proxy mutations.
  *
@@ -113,32 +106,7 @@ declare function reactiveMap<K, V>(initial?: Iterable<[K, V]>): ReactiveMap<K, V
  */
 declare function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T>;
 //#endregion
-//#region src/types.d.ts
-/**
- * Primitive types that should not be proxied or snapshot-cloned.
- * Used by `Snapshot<T>` to identify leaf types that pass through unchanged.
- */
-type Primitive = string | number | boolean | null | undefined | symbol | bigint;
-/**
- * Function type shorthand.
- * Functions are treated as snapshot leaves -- they pass through unchanged
- * because freezing or cloning them would break callable references.
- */
-type AnyFunction = (...args: unknown[]) => unknown;
-/**
- * Types that `snapshot()` returns as-is (no deep clone or freeze).
- * These are either already immutable-ish (Date, RegExp), use internal slots
- * that proxies can't intercept (Map, Set, WeakMap, WeakSet), or can't be
- * meaningfully frozen (functions, Promises, Errors).
- */
-type SnapshotLeaf = Primitive | AnyFunction | Date | RegExp | Error | Map<unknown, unknown> | Set<unknown> | WeakMap<object, unknown> | WeakSet<object> | Promise<unknown>;
-/**
- * Recursively converts an object type to a deeply readonly version.
- * Leaf types (primitives, Date, Map, etc.) pass through unchanged.
- */
-type Snapshot<T> = T extends SnapshotLeaf ? T : T extends Array<infer U> ? ReadonlyArray<Snapshot<U>> : T extends object ? { readonly [K in keyof T]: Snapshot<T[K]> } : T;
-//#endregion
-//#region src/core.d.ts
+//#region src/core/core.d.ts
 /**
  * Wraps a class instance in a reactive proxy.
  *
@@ -170,7 +138,7 @@ declare function subscribe(proxy: object, callback: () => void): () => void;
  */
 declare function getVersion(proxy: object): number;
 //#endregion
-//#region src/snapshot.d.ts
+//#region src/snapshot/snapshot.d.ts
 /**
  * Creates an immutable, deeply-frozen snapshot of the store proxy's current state.
  *
@@ -189,27 +157,16 @@ declare function getVersion(proxy: object): number;
  */
 declare function snapshot<T extends object>(proxyStore: T): Snapshot<T>;
 //#endregion
-//#region src/useStore.d.ts
-/**
- * Subscribe to a store proxy with an explicit selector.
- *
- * Re-renders only when the selected value changes (compared via `Object.is`
- * by default, or a custom `isEqual`).
- *
- * @param proxyStore - A reactive proxy created by `store()`.
- * @param selector  - Picks data from the immutable snapshot.
- * @param isEqual   - Optional custom equality function (default: `Object.is`).
- */
-declare function useStore<T extends object, S>(proxyStore: T, selector: (snap: Snapshot<T>) => S, isEqual?: (a: S, b: S) => boolean): S;
+//#region src/utils/equality/equality.d.ts
 /**
- * Subscribe to a store proxy **without** a selector (auto-tracked mode).
- *
- * Returns a `proxy-compare` tracking proxy over the immutable snapshot.
- * The component only re-renders when a property it actually read changes.
+ * Shallow-equal comparison for objects and arrays.
+ * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.
  *
- * @param proxyStore - A reactive proxy created by `store()`.
+ * - Primitives compared with `Object.is`.
+ * - Arrays: length + element-wise `Object.is`.
+ * - Objects: key count + value-wise `Object.is`.
  */
-declare function useStore<T extends object>(proxyStore: T): Snapshot<T>;
+declare function shallowEqual<T>(a: T, b: T): boolean;
 //#endregion
-export { type ReactiveMap, type ReactiveSet, type Snapshot, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe, useStore };
+export { type ReactiveMap, type ReactiveSet, type Snapshot, getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/utils.ts","../src/collections.ts","../src/types.ts","../src/core.ts","../src/snapshot.ts","../src/useStore.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/utils/internal/internal.ts","../src/collections/collections.ts","../src/core/core.ts","../src/snapshot/snapshot.ts","../src/utils/equality/equality.ts"],"mappings":";;;;;;AAOA;;cAAa,SAAA;;;;;AAAb;;;;;;;;ACUA;;;cAAa,WAAA;EAAA,QACH,SAAA;EAGM;EAAd,QAAA,GAAW,CAAA,EAAG,CAAA;EAGqB;cAAvB,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA;EAmB1B;EAAA,IALL,IAAA,CAAA;EAWK;EANT,GAAA,CAAI,GAAA,EAAK,CAAA,GAAI,CAAA;EAWM;EALnB,GAAA,CAAI,GAAA,EAAK,CAAA;EA6BgB;EAxBzB,GAAA,CAAI,GAAA,EAAK,CAAA,EAAG,KAAA,EAAO,CAAA;EA6BQ;EAlB3B,MAAA,CAAO,GAAA,EAAK,CAAA;EAuBiB;EAf7B,KAAA,CAAA;EAeW;EAVX,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EAeS;EAVlC,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EAU8B;EALzD,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EAYO;EAPvC,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA,EAAG,CAAA;EAOpC;EAAA,CAApB,MAAA,CAAO,QAAA,KAAa,gBAAA,EAAkB,CAAA,EAAG,CAAA;AAAA;;;;;;;;;;;;;;cAoB/B,WAAA;EAAA,QACH,SAAA;EA9EJ;EAiFJ,MAAA,EAAQ,CAAA;EA3ER;cA8EY,OAAA,GAAU,QAAA,CAAS,CAAA;EA9E3B;EAAA,IAyFA,IAAA,CAAA;EApFK;EAyFT,GAAA,CAAI,KAAA,EAAO,CAAA;EAzFQ;EA8FnB,GAAA,CAAI,KAAA,EAAO,CAAA;EAnFX;EA2FA,MAAA,CAAO,KAAA,EAAO,CAAA;EA3FP;EAmGP,KAAA,CAAA;EAtFA;EA2FA,IAAA,CAAA,GAAQ,gBAAA,CAAiB,CAAA;EA3FA;EAgGzB,MAAA,CAAA,GAAU,gBAAA,CAAiB,CAAA;EA3FjB;EAgGV,OAAA,CAAA,GAAW,gBAAA,EAAkB,CAAA,EAAG,CAAA;EA3FhC;EAgGA,OAAA,CAAQ,QAAA,GAAW,KAAA,EAAO,CAAA,EAAG,GAAA,EAAK,CAAA,EAAG,GAAA,EAAK,WAAA,CAAY,CAAA;EAhGzB;EAAA,CAuG5B,MAAA,CAAO,QAAA,KAAa,gBAAA,CAAiB,CAAA;AAAA;;;;;;;iBAaxB,WAAA,MAAA,CACd,OAAA,GAAU,QAAA,EAAU,CAAA,EAAG,CAAA,KACtB,WAAA,CAAY,CAAA,EAAG,CAAA;;;;;;;iBAUF,WAAA,GAAA,CAAe,OAAA,GAAU,QAAA,CAAS,CAAA,IAAK,WAAA,CAAY,CAAA;;;;AAvMnE;;;;;;;;;;;iBCmRgB,KAAA,kBAAA,CAAwB,QAAA,EAAU,CAAA,GAAI,CAAA;;;;;;;;;iBAYtC,SAAA,CAAU,KAAA,UAAe,QAAA;;;;;;;;iBAkBzB,UAAA,CAAW,KAAA;;;;;AF3T3B;;;;;;;;ACUA;;;;;;iBEwUgB,QAAA,kBAAA,CAA2B,UAAA,EAAY,CAAA,GAAI,QAAA,CAAS,CAAA;;;;;;AHlVpE;;;;;iBICgB,YAAA,GAAA,CAAgB,CAAA,EAAG,CAAA,EAAG,CAAA,EAAG,CAAA"}

package/dist/index.mjs

@@ -1,8 +1,6 @@
-import { a as subscribe, c as shallowEqual, i as store, n as getInternal, o as PROXYABLE, r as getVersion, t as snapshot } from "./snapshot-fVu34Cr6.mjs";
-import { createProxy, isChanged } from "proxy-compare";
-import { useCallback, useRef, useSyncExternalStore } from "react";
+import { a as subscribe, i as store, o as PROXYABLE, r as getVersion, t as snapshot } from "./snapshot-C8JDLu8L.mjs";
 
-//#region src/collections.ts
+//#region src/collections/collections.ts
 /**
 * A Map-like class backed by a plain array so `store()` can proxy mutations.
 *
@@ -168,59 +166,30 @@ function reactiveSet(initial) {
 }
 
 //#endregion
-//#region src/useStore.ts
-function useStore(proxyStore, selector, isEqual) {
-	getInternal(proxyStore);
-	const subscribe$1 = useCallback((onStoreChange) => subscribe(proxyStore, onStoreChange), [proxyStore]);
-	const snapRef = useRef(void 0);
-	const resultRef = useRef(void 0);
-	const affected = useRef(/* @__PURE__ */ new WeakMap()).current;
-	const proxyCache = useRef(/* @__PURE__ */ new WeakMap()).current;
-	const prevSnapRef = useRef(void 0);
-	const wrappedRef = useRef(void 0);
-	const getSnapshot = () => selector ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) : getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef);
-	return useSyncExternalStore(subscribe$1, getSnapshot, getSnapshot);
-}
+//#region src/utils/equality/equality.ts
 /**
-* `getSnapshot` implementation for selector mode.
-*
-* Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise
-* runs the selector against the new snapshot and compares the result to the
-* previous one via `Object.is` (or a custom `isEqual`). Returns the previous
-* result reference when equal, preventing unnecessary React re-renders.
+* Shallow-equal comparison for objects and arrays.
+* Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.
 *
-* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
+* - Primitives compared with `Object.is`.
+* - Arrays: length + element-wise `Object.is`.
+* - Objects: key count + value-wise `Object.is`.
 */
-function getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual) {
-	const nextSnap = snapshot(proxyStore);
-	if (snapRef.current === nextSnap && resultRef.current !== void 0) return resultRef.current;
-	const nextResult = selector(nextSnap);
-	snapRef.current = nextSnap;
-	if (resultRef.current !== void 0 && (isEqual ? isEqual(resultRef.current, nextResult) : Object.is(resultRef.current, nextResult))) return resultRef.current;
-	resultRef.current = nextResult;
-	return nextResult;
-}
-/**
-* `getSnapshot` implementation for auto-tracked (selectorless) mode.
-*
-* Uses `proxy-compare` to diff only the properties the component actually read.
-* If the snapshot reference is the same, returns the cached tracking proxy.
-* If the snapshot changed but no tracked property differs (`isChanged` returns
-* false), also returns the cached proxy -- avoiding re-render. Only when a
-* relevant property changed does it create a new `createProxy` wrapper.
-*
-* Pure function -- no hooks, safe to call from `useSyncExternalStore`.
-*/
-function getAutoTrackSnapshot(proxyStore, affected, proxyCache, prevSnapRef, wrappedRef) {
-	const nextSnap = snapshot(proxyStore);
-	if (prevSnapRef.current === nextSnap) return wrappedRef.current;
-	if (prevSnapRef.current !== void 0 && !isChanged(prevSnapRef.current, nextSnap, affected)) return wrappedRef.current;
-	prevSnapRef.current = nextSnap;
-	const wrapped = createProxy(nextSnap, affected, proxyCache);
-	wrappedRef.current = wrapped;
-	return wrapped;
+function shallowEqual(a, b) {
+	if (Object.is(a, b)) return true;
+	if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
+	if (Array.isArray(a) && Array.isArray(b)) {
+		if (a.length !== b.length) return false;
+		for (let i = 0; i < a.length; i++) if (!Object.is(a[i], b[i])) return false;
+		return true;
+	}
+	const keysA = Object.keys(a);
+	const keysB = Object.keys(b);
+	if (keysA.length !== keysB.length) return false;
+	for (const key of keysA) if (!Object.hasOwn(b, key) || !Object.is(a[key], b[key])) return false;
+	return true;
 }
 
 //#endregion
-export { getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe, useStore };
+export { getVersion, reactiveMap, reactiveSet, shallowEqual, snapshot, store, subscribe };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":["subscribe","coreSubscribe"],"sources":["../src/collections.ts","../src/useStore.ts"],"sourcesContent":["import {PROXYABLE} from './utils';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","import {createProxy, isChanged} from 'proxy-compare';\nimport {useCallback, useRef, useSyncExternalStore} from 'react';\nimport {subscribe as coreSubscribe, getInternal} from './core';\nimport {snapshot} from './snapshot';\nimport type {Snapshot} from './types';\n\n// ── Overloads ─────────────────────────────────────────────────────────────────\n\n/**\n * Subscribe to a store proxy with an explicit selector.\n *\n * Re-renders only when the selected value changes (compared via `Object.is`\n * by default, or a custom `isEqual`).\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n * @param selector  - Picks data from the immutable snapshot.\n * @param isEqual   - Optional custom equality function (default: `Object.is`).\n */\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S;\n\n/**\n * Subscribe to a store proxy **without** a selector (auto-tracked mode).\n *\n * Returns a `proxy-compare` tracking proxy over the immutable snapshot.\n * The component only re-renders when a property it actually read changes.\n *\n * @param proxyStore - A reactive proxy created by `store()`.\n */\nexport function useStore<T extends object>(proxyStore: T): Snapshot<T>;\n\n// ── Implementation ────────────────────────────────────────────────────────────\n\nexport function useStore<T extends object, S>(\n  proxyStore: T,\n  selector?: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): Snapshot<T> | S {\n  // Validate that the argument is actually a store proxy (throws if not).\n  getInternal(proxyStore);\n\n  // Stable subscribe function (internal identity never changes for a given store).\n  const subscribe = useCallback(\n    (onStoreChange: () => void) => coreSubscribe(proxyStore, onStoreChange),\n    [proxyStore],\n  );\n\n  // ── Refs used by both modes (always allocated to satisfy Rules of Hooks) ──\n\n  // Selector mode refs\n  const snapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const resultRef = useRef<S | undefined>(undefined);\n\n  // Auto-track mode refs\n  const affected = useRef(new WeakMap<object, unknown>()).current;\n  const proxyCache = useRef(new WeakMap<object, unknown>()).current;\n  const prevSnapRef = useRef<Snapshot<T> | undefined>(undefined);\n  const wrappedRef = useRef<Snapshot<T> | undefined>(undefined);\n\n  // ── Single getSnapshot for useSyncExternalStore ───────────────────────────\n\n  const getSnapshot = (): Snapshot<T> | S =>\n    selector\n      ? getSelectorSnapshot(proxyStore, snapRef, resultRef, selector, isEqual)\n      : getAutoTrackSnapshot(\n          proxyStore,\n          affected,\n          proxyCache,\n          prevSnapRef,\n          wrappedRef,\n        );\n\n  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n}\n\n// ── Selector mode logic (pure function, no hooks) ─────────────────────────────\n\n/**\n * `getSnapshot` implementation for selector mode.\n *\n * Fast-paths when the snapshot reference hasn't changed (O(1)). Otherwise\n * runs the selector against the new snapshot and compares the result to the\n * previous one via `Object.is` (or a custom `isEqual`). Returns the previous\n * result reference when equal, preventing unnecessary React re-renders.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getSelectorSnapshot<T extends object, S>(\n  proxyStore: T,\n  snapRef: React.RefObject<Snapshot<T> | undefined>,\n  resultRef: React.RefObject<S | undefined>,\n  selector: (snap: Snapshot<T>) => S,\n  isEqual?: (a: S, b: S) => boolean,\n): S {\n  const nextSnap = snapshot(proxyStore);\n\n  // Fast path: same snapshot reference → same result.\n  if (snapRef.current === nextSnap && resultRef.current !== undefined) {\n    return resultRef.current;\n  }\n\n  const nextResult = selector(nextSnap);\n  snapRef.current = nextSnap;\n\n  // Check equality with previous result.\n  if (\n    resultRef.current !== undefined &&\n    (isEqual\n      ? isEqual(resultRef.current, nextResult)\n      : Object.is(resultRef.current, nextResult))\n  ) {\n    return resultRef.current;\n  }\n\n  resultRef.current = nextResult;\n  return nextResult;\n}\n\n// ── Auto-tracked (selectorless) mode logic (pure function, no hooks) ──────────\n\n/**\n * `getSnapshot` implementation for auto-tracked (selectorless) mode.\n *\n * Uses `proxy-compare` to diff only the properties the component actually read.\n * If the snapshot reference is the same, returns the cached tracking proxy.\n * If the snapshot changed but no tracked property differs (`isChanged` returns\n * false), also returns the cached proxy -- avoiding re-render. Only when a\n * relevant property changed does it create a new `createProxy` wrapper.\n *\n * Pure function -- no hooks, safe to call from `useSyncExternalStore`.\n */\nfunction getAutoTrackSnapshot<T extends object>(\n  proxyStore: T,\n  affected: WeakMap<object, unknown>,\n  proxyCache: WeakMap<object, unknown>,\n  prevSnapRef: React.RefObject<Snapshot<T> | undefined>,\n  wrappedRef: React.RefObject<Snapshot<T> | undefined>,\n): Snapshot<T> {\n  const nextSnap = snapshot(proxyStore);\n\n  // If the raw snapshot is the same reference, nothing changed.\n  if (prevSnapRef.current === nextSnap) {\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Check if any property the component actually read has changed.\n  if (\n    prevSnapRef.current !== undefined &&\n    !isChanged(prevSnapRef.current, nextSnap, affected)\n  ) {\n    // No property the component cares about changed → return same wrapped proxy.\n    return wrappedRef.current as Snapshot<T>;\n  }\n\n  // Something relevant changed — create a new tracking proxy.\n  prevSnapRef.current = nextSnap;\n  const wrapped = createProxy(nextSnap, affected, proxyCache) as Snapshot<T>;\n  wrappedRef.current = wrapped;\n  return wrapped;\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/collections/collections.ts","../src/utils/equality/equality.ts"],"sourcesContent":["import {PROXYABLE} from '../utils/internal/internal';\n\n// ── ReactiveMap ───────────────────────────────────────────────────────────────\n\n/**\n * A Map-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Map` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.set()` would be invisible to the store. `ReactiveMap` solves this by\n * storing entries in a plain array (`_entries`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ users: reactiveMap<string, User>() });\n * myStore.users.set('id1', { name: 'Alice' }); // reactive\n * ```\n */\nexport class ReactiveMap<K, V> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _entries: [K, V][] = [];\n\n  /** Deduplicates initial entries by key (last value wins, matching native `Map`). */\n  constructor(initial?: Iterable<[K, V]>) {\n    if (initial) {\n      for (const [k, v] of initial) {\n        const index = this._entries.findIndex(([ek]) => Object.is(ek, k));\n        if (index !== -1) {\n          this._entries[index] = [k, v];\n        } else {\n          this._entries.push([k, v]);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of entries. */\n  get size(): number {\n    return this._entries.length;\n  }\n\n  /** Returns the value for `key`, or `undefined`. O(n) linear scan. */\n  get(key: K): V | undefined {\n    const entry = this._entries.find(([k]) => Object.is(k, key));\n    return entry ? entry[1] : undefined;\n  }\n\n  /** Returns `true` if `key` exists. O(n) linear scan. */\n  has(key: K): boolean {\n    return this._entries.some(([k]) => Object.is(k, key));\n  }\n\n  /** Sets `key` to `value`. Updates in-place if key exists, appends otherwise. */\n  set(key: K, value: V): this {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index !== -1) {\n      this._entries[index] = [key, value];\n    } else {\n      this._entries.push([key, value]);\n    }\n    return this;\n  }\n\n  /** Removes the entry for `key`. Returns `true` if found. */\n  delete(key: K): boolean {\n    const index = this._entries.findIndex(([k]) => Object.is(k, key));\n    if (index === -1) return false;\n    this._entries.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all entries. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._entries.splice(0, this._entries.length);\n  }\n\n  /** Returns an iterator over the keys. */\n  keys(): IterableIterator<K> {\n    return this._entries.map(([k]) => k)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<V> {\n    return this._entries.map(([, v]) => v)[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [key, value] pairs. */\n  entries(): IterableIterator<[K, V]> {\n    return this._entries.map(([k, v]) => [k, v] as [K, V])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each entry, matching the native `Map.forEach` signature. */\n  forEach(callback: (value: V, key: K, map: ReactiveMap<K, V>) => void): void {\n    for (const [k, v] of this._entries) {\n      callback(v, k, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over [key, value] pairs. */\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.entries();\n  }\n}\n\n// ── ReactiveSet ───────────────────────────────────────────────────────────────\n\n/**\n * A Set-like class backed by a plain array so `store()` can proxy mutations.\n *\n * Native `Set` uses internal slots that ES6 Proxy can't intercept, so mutations\n * like `.add()` would be invisible to the store. `ReactiveSet` solves this by\n * storing items in a plain array (`_items`) that the proxy can track.\n *\n * Usage:\n * ```ts\n * const myStore = store({ tags: reactiveSet<string>(['urgent']) });\n * myStore.tags.add('bug'); // reactive\n * ```\n */\nexport class ReactiveSet<T> {\n  static [PROXYABLE] = true;\n\n  /** @internal Backing storage — proxied by store(). */\n  _items: T[] = [];\n\n  /** Deduplicates initial values using `Object.is` comparison. */\n  constructor(initial?: Iterable<T>) {\n    if (initial) {\n      for (const v of initial) {\n        if (!this._items.some((item) => Object.is(item, v))) {\n          this._items.push(v);\n        }\n      }\n    }\n  }\n\n  /** Returns the number of unique items. */\n  get size(): number {\n    return this._items.length;\n  }\n\n  /** Returns `true` if `value` exists. O(n) linear scan. */\n  has(value: T): boolean {\n    return this._items.some((item) => Object.is(item, value));\n  }\n\n  /** Adds `value` if not already present (no-op for duplicates). */\n  add(value: T): this {\n    if (!this.has(value)) {\n      this._items.push(value);\n    }\n    return this;\n  }\n\n  /** Removes `value`. Returns `true` if found. */\n  delete(value: T): boolean {\n    const index = this._items.findIndex((item) => Object.is(item, value));\n    if (index === -1) return false;\n    this._items.splice(index, 1);\n    return true;\n  }\n\n  /** Removes all items. Uses splice to trigger proxy notification. */\n  clear(): void {\n    this._items.splice(0, this._items.length);\n  }\n\n  /** Returns an iterator over the values (same as `values()`, matching Set API). */\n  keys(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over the values. */\n  values(): IterableIterator<T> {\n    return this._items[Symbol.iterator]();\n  }\n\n  /** Returns an iterator over [value, value] pairs, matching the native Set API. */\n  entries(): IterableIterator<[T, T]> {\n    return this._items.map((v) => [v, v] as [T, T])[Symbol.iterator]();\n  }\n\n  /** Calls `callback` for each item, matching the native `Set.forEach` signature. */\n  forEach(callback: (value: T, key: T, set: ReactiveSet<T>) => void): void {\n    for (const v of this._items) {\n      callback(v, v, this);\n    }\n  }\n\n  /** Enables `for...of` iteration over values. */\n  [Symbol.iterator](): IterableIterator<T> {\n    return this.values();\n  }\n}\n\n// ── Factory functions ─────────────────────────────────────────────────────────\n\n/**\n * Creates a reactive Map-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of `[key, value]` pairs.\n */\nexport function reactiveMap<K, V>(\n  initial?: Iterable<[K, V]>,\n): ReactiveMap<K, V> {\n  return new ReactiveMap(initial);\n}\n\n/**\n * Creates a reactive Set-like collection backed by a plain array.\n * Wrap the parent object with `store()` for full reactivity.\n *\n * @param initial - Optional iterable of values.\n */\nexport function reactiveSet<T>(initial?: Iterable<T>): ReactiveSet<T> {\n  return new ReactiveSet(initial);\n}\n","/**\n * Shallow-equal comparison for objects and arrays.\n * Useful as a custom `isEqual` for `useStore` selectors that return objects/arrays.\n *\n * - Primitives compared with `Object.is`.\n * - Arrays: length + element-wise `Object.is`.\n * - Objects: key count + value-wise `Object.is`.\n */\nexport function shallowEqual<T>(a: T, b: T): boolean {\n  if (Object.is(a, b)) return true;\n  if (\n    typeof a !== 'object' ||\n    a === null ||\n    typeof b !== 'object' ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (Array.isArray(a) && Array.isArray(b)) {\n    if (a.length !== b.length) return false;\n    for (let i = 0; i < a.length; i++) {\n      if (!Object.is(a[i], b[i])) return false;\n    }\n    return true;\n  }\n\n  const keysA = Object.keys(a);\n  const keysB = Object.keys(b);\n  if (keysA.length !== keysB.length) return false;\n\n  for (const key of keysA) {\n    if (\n      !Object.hasOwn(b, key) ||\n      !Object.is(\n        (a as Record<string, unknown>)[key],\n        (b as Record<string, unknown>)[key],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":"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"}