@yiin/reactive-proxy-state 1.0.44 → 2.0.0

package/dist/location.d.ts

@@ -0,0 +1,288 @@
+import type { EmitFunction, Path, StateEvent } from "./types";
+/**
+ * Where each wrapped object sits in its state tree.
+ *
+ * Every raw object that has a proxy has a location node. A node records the
+ * places that hold it (a parent node and a key), so a path is read when an
+ * event is made, never fixed when the proxy is made. Structural changes move
+ * places: `relinkArray` gives array items their new index, `attachValue` and
+ * `detachPlace` follow assignments and removals. A node with no place under a
+ * root is detached and emits nothing.
+ *
+ * One object can sit at several places (`list[0] = list[1]`). The wire cannot
+ * carry shared identity, so the remote holds copies; a write through the
+ * shared object then emits one event per place. Places of such aliases come
+ * from the walk that stores a value (root creation, assignment, insertion,
+ * array reorders), so they do not depend on what was read before.
+ *
+ * A place names its parent weakly: a child never keeps a removed parent or
+ * an abandoned root alive.
+ *
+ * An object reachable from two roots emits to one of them (see `locate`).
+ */
+export declare const enum ContainerKind {
+    Plain = 0,
+    Map = 1,
+    Set = 2
+}
+export interface LocationRoot {
+    emit: EmitFunction | undefined;
+    path: Path;
+    /**
+     * The root emits on a later microtask (`{ async: true }`): its events
+     * wait, so they also copy what a write removes (see `copyPayload`).
+     */
+    async: boolean;
+    /**
+     * Events made under this root and not delivered yet, oldest first, while
+     * a write that made several is delivering them (see `deliver`).
+     */
+    undelivered: Undelivered | undefined;
+}
+/** A root's queue: `events[next]` is the oldest event not delivered yet. */
+interface Undelivered {
+    events: StateEvent[];
+    next: number;
+}
+export declare class Place {
+    private readonly parentRef;
+    /** The container node's `id`: compares places without reading the WeakRef. */
+    readonly parentId: number;
+    /** Property name, array index (number), map key; unused for set members. */
+    key: unknown;
+    constructor(parent: LocationNode, key: unknown);
+    /** The container's node; undefined once the container was collected. */
+    get parent(): LocationNode | undefined;
+}
+export interface LocationNode {
+    /** Unique per node, never reused. */
+    id: number;
+    raw: object;
+    kind: ContainerKind;
+    places: Place[];
+    root: LocationRoot | undefined;
+    /** The root this object was first read under; it wins when two roots hold the object. */
+    scope: LocationRoot | undefined;
+    /** The object's live proxy (its `globalSeen` entry), read without a second map lookup. */
+    proxy: object | undefined;
+    /** The proxy this object had before it was evicted, to reuse it if the object comes back. */
+    evicted: WeakRef<object> | undefined;
+    /** The last `relinkArray` call that placed this object (tells repeats apart). */
+    relinked: number;
+    /** In that call: how many of its old places in the array it has not met again yet. */
+    relinkedPlaces: number;
+    /**
+     * A child's place under this object, or under an object below it, was
+     * dropped while this object was detached. Storing it again walks its
+     * children to give those places back.
+     */
+    lostLink: boolean;
+    /**
+     * The object had no own accessor property when its proxy first wrote to
+     * it (see `writesThroughSetter`); undefined before that write.
+     */
+    dataOnly: boolean | undefined;
+    /**
+     * How many places name this node as their container: every `Place` made
+     * with it counts, and each place dropped from its object's `places` stops
+     * counting. A place whose object was collected still counts, so the
+     * number is never below the places there are (see `relink`).
+     */
+    childPlaces: number;
+    /** The last store walk that met this object (see `enterAdopt`). */
+    walk: number;
+    /** The last store that put this node on its list of nodes to prune (see `touch`). */
+    touched: number;
+    /** How many places the node kept at its last full `prunePlaces`. */
+    pruned: number;
+    /** The places of a node with more than `WIDE` of them, by container and key (see `findPlace`). */
+    index: PlaceIndex | undefined;
+}
+/**
+ * The places of one node by container id, then by key when one container
+ * holds the object at several keys. It belongs to `places` while that array
+ * keeps `length` items; a change of an item in place (a splice, a new key)
+ * drops it. A push through `pushPlace` keeps it.
+ */
+interface PlaceIndex {
+    places: Place[];
+    length: number;
+    byParent: Map<number, Place | Map<unknown, Place>>;
+}
+export declare function getLocationNode(raw: object): LocationNode | undefined;
+export declare function ensureLocationNode(raw: object): LocationNode;
+/**
+ * Does a write to `prop` of `target` (raw; its node is `node`) call an own
+ * setter? Read from the property's descriptor, unless the object had no own
+ * accessor when its proxy first wrote to it: a write through a proxy adds
+ * only data properties, so then there is none to find, and no descriptor
+ * is made per write. An accessor added later (`Object.defineProperty`) is
+ * outside the supported input. An object with more than 64 own keys is not
+ * scanned and reads the descriptor at every write.
+ */
+export declare function writesThroughSetter(target: object, prop: PropertyKey, node: LocationNode): boolean;
+/** Where an event goes: one root and every path of the object under it. */
+export interface Target {
+    root: LocationRoot;
+    paths: Path[];
+}
+/**
+ * Where an event about `node` (plus `tail`) goes: every current place of the
+ * object, under one root. Undefined when the object is detached or that root
+ * has no emit function.
+ *
+ * An object under two roots (a replica built on raw objects it shares with
+ * its source) emits only to its scope, the root it was first read under, so
+ * applying an event to the replica cannot echo back to the source.
+ *
+ * A write that finds no root is counted in `proxyStats.detachedWrites`.
+ */
+export declare function locate(node: LocationNode, tail?: PropertyKey): Target | undefined;
+/** Is the object somewhere under a root (with or without an emit function)? */
+export declare function isAttached(node: LocationNode): boolean;
+/**
+ * Send `event` to every path of `target`. Its payload holds copies already
+ * (`copyPayload` or `copyPayloadAfter`, made before the write). Every
+ * further path gets copies of the stored values (`newValue`, `value`,
+ * `items`), all made before the first emit, so a listener that changes one
+ * cannot change another, and two remote places never share one object.
+ * The first path gets `event` itself. What the write removed is copied per
+ * path only where `copyPayload` copied it (an async root); otherwise every
+ * path carries the removed value itself, shared by the events.
+ */
+export declare function dispatch(target: Target, event: StateEvent): void;
+/**
+ * Deliver the `events` of one write to `root.emit`, in order, after the
+ * events earlier writes left undelivered under this root.
+ *
+ * A listener can write while it receives an event. That write changed the
+ * state after the events still waiting (the other places of an alias), so
+ * its own events go after them: it adds them to the root's queue, then
+ * delivers the queue from the oldest event, before it returns. So events
+ * reach `emit` in the order the state changed, every write is delivered
+ * before it returns, and a write made while nothing waits is delivered at
+ * once, inside the listener call that made it.
+ *
+ * An `emit` that throws does not stop the others: every event in the queue
+ * is delivered once, each for a write that already changed the state, then
+ * the first error reaches the write that was delivering them. A listener
+ * that called that write may catch it and go on.
+ */
+export declare function deliver(root: LocationRoot, events: StateEvent[]): void;
+/** What `copyPayload` did. */
+export declare const enum Copied {
+    /** Nothing: the payload reaches its container (see `copyPayloadReaching`). */
+    Reaches = 0,
+    /** Copied the payload. */
+    Done = 1,
+    /**
+     * Copied the payload, and the values it stores (`newValue`, `value`,
+     * `items`) are fresh (see `cloneStored`): the place walk of this store
+     * would find nothing in them, so `attachValue` and `relinkArray` skip it.
+     * The finding holds for this store only; a later store of the same
+     * values walks them again.
+     */
+    Fresh = 2
+}
+/**
+ * Replace the payload fields of `event` (live values) with deep copies, made
+ * before the write that changes `container` (raw). `items` and `oldValues`
+ * are arrays the wrapper made for this event and only reads; each is one
+ * payload, copied whole, with one copy limit, and kept as it is when it
+ * holds no object. A payload too large to copy throws a `SnapshotLimitError`
+ * and leaves `event` as it was, so the write is never made.
+ *
+ * What the write stores (`newValue`, `value`, `items`) is always copied: it
+ * stays in the tree, where later writes change it, and a replica needs it
+ * as it was. What the write removes (`oldValue`, `oldValues`, and the
+ * `value` of a `set-delete`) is copied only for an async root
+ * (`target.root.async`), whose events wait for a microtask. A synchronous
+ * root delivers the event before the write returns, and sends the removed
+ * value itself, as 1.0.44 did, so it never refuses a removal. Assignment
+ * `newValue` copies keep array items only. Reorders keep properties on
+ * nested arrays; the other fields keep every array's properties (see `Named`).
+ *
+ * A payload that reaches `container` would be copied as `container` is
+ * before the write. Then nothing is copied and the result is
+ * `Copied.Reaches`: the caller makes the write on `shallowCopy(container)`
+ * and copies with `copyPayloadReaching`, still before the write.
+ *
+ * `held` comes from `heldItems` for the store of `newValue`: the place walk
+ * of that store skips those items, so the copy does not check freshness.
+ */
+export declare function copyPayload(event: StateEvent | undefined, target: Target | undefined, container: object, held?: Set<object>): Copied;
+/**
+ * `copyPayloadAfter` for a write that `copyPayload` refused because its
+ * payload reaches `container`. A getter in that payload would be read
+ * before the write, and could give another value after it, so an accessor
+ * property in it is refused (an `UnsupportedStateError`) without being
+ * read. `after` comes from `shallowCopy`, which refuses the container's own.
+ */
+export declare function copyPayloadReaching(event: StateEvent, target: Target, container: object, after: object): void;
+/**
+ * Like `copyPayload`, for a payload that reaches `container`: `after` (a
+ * `shallowCopy` of `container` with the write made on it) stands in for
+ * `container`, so the payload is copied as it will be after the write,
+ * before the write. Throws a `SnapshotLimitError` when it is too large to
+ * copy; the write is then never made, and nothing needs to be put back.
+ */
+export declare function copyPayloadAfter(event: StateEvent, target: Target, container: object, after: object): void;
+/**
+ * A copy of `container` (raw) that holds the same entries, of the same kind
+ * and prototype: an array holds the same items, a map the same entries, a
+ * set the same members, an object the same own enumerable properties (as
+ * data). A write is made on it to copy a payload as it will be after that
+ * write (see `copyPayloadReaching`). An own enumerable accessor of an object
+ * is refused (an `UnsupportedStateError`) without being read.
+ */
+export declare function shallowCopy(container: object): any;
+/**
+ * Record that a proxy read found `raw` at `parent[key]`. Called on every read
+ * of a nested object, so the common case (place already known) is one
+ * compare, and a wide node finds the place in its index.
+ */
+export declare function notePlace(node: LocationNode, parent: LocationNode, key: unknown): void;
+/** `parent[key]` no longer holds `value`. */
+export declare function detachPlace(value: object, parent: LocationNode, key: unknown): void;
+/**
+ * `heldBefore` for a store of `value` over `replaced`, the value it writes
+ * over when its container was in the tree (see `attachedBefore`); undefined
+ * when `replaced` has no node. Made before the write, for `copyPayload` and
+ * `attachValue`.
+ */
+export declare function heldItems(value: unknown, replaced: unknown): Set<object> | undefined;
+/**
+ * `parent[key]` now holds `value` (a raw object). A `fresh` value (the copy
+ * this store made found it fresh, see `cloneStored`) has nothing to place.
+ * `replaced` is the value the store wrote over, when `parent` was in the
+ * tree before the store (see `attachedBefore`), and `held` is
+ * `heldItems(value, replaced)`.
+ */
+export declare function attachValue(value: object, parent: LocationNode, key: unknown, fresh: boolean, replaced?: unknown, held?: Set<object>): void;
+/**
+ * A new root: give places to the objects in its initial value that need
+ * them now, which are the aliases (an object at two places) and the
+ * containers above them. Other objects get their place when they are read.
+ */
+export declare function adoptRoot(node: LocationNode): void;
+/**
+ * After a structural change of `array` (its node `arrayNode`): items from
+ * index `from` to the end get their current index, `removed` items lose
+ * their place here, and `inserted` items (raw) join the tree.
+ */
+export declare function relinkArray(arrayNode: LocationNode, array: readonly unknown[], from: number, removed?: readonly unknown[], inserted?: readonly unknown[], insertedFresh?: boolean): void;
+/**
+ * After `sort`, `reverse`, `fill` or `copyWithin`: like `relinkArray` from
+ * index 0, and an object without a node that now sits at two indexes (an
+ * alias the change made) gets a node with both places.
+ */
+export declare function relinkReorder(arrayNode: LocationNode, array: readonly unknown[], removed: readonly unknown[], inserted?: readonly unknown[]): void;
+/**
+ * Drop the proxy cache entries of an object that left the tree, and of its
+ * children that left with it, so GC can collect them. An object that is
+ * still placed under a root (it moved) keeps its proxy.
+ */
+export declare function evictDeep(value: any, parent?: LocationNode): void;
+/** The proxy an evicted object had, if it is still alive; it goes back in the caches. */
+export declare function restoreEvicted(node: LocationNode): object | undefined;
+export {};

package/dist/reactive.d.ts

@@ -4,6 +4,10 @@ import { EmitFunction, Path, ReactiveOptions } from "./types";
  */
 export declare function isReactive(value: any): boolean;
 /**
- * Create a reactive proxy for an object
+ * Create a reactive proxy for an object.
+ *
+ * Called by users, this makes a root: events from anywhere below it go to
+ * `emit`, with paths that start with `path`. Nested objects are wrapped on
+ * read by `wrapChild`.
  */
 export declare function reactive<T extends object>(obj: T, emit?: EmitFunction, path?: Path, options?: ReactiveOptions): T;

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+import type { StateEvent } from "./types";
 /**
  * Returns the raw, original object underlying a reactive proxy.
  * If the input is not a proxy, returns the input itself.
@@ -6,10 +7,12 @@ export declare function toRaw<T>(observed: T): T;
 /**
  * Strip proxy refs from spread results before storing in raw state.
  * Prevents unbounded proxy nesting from `{ ...reactiveProxy }` patterns.
+ * The value and its direct children only: the place walk of the store puts
+ * the raw object in place of a proxy deeper down (see `storeRaw` in
+ * location.ts), and a fresh value (see `cloneStored`) holds no proxy.
  */
 export declare function unwrapForStore(value: any): any;
 export declare const pathCache: WeakMap<object, Map<string, any>>;
-export declare const pathConcatCache: Map<string, any[]>;
 export declare const globalSeen: WeakMap<any, any>;
 export declare const wrapperCache: WeakMap<object, object>;
 export declare const proxyStats: {
@@ -20,6 +23,11 @@ export declare const proxyStats: {
     objects: number;
     /** Number of old proxied values evicted when replaced via set trap */
     staleEvicted: number;
+    /**
+     * Writes through a proxy whose object is in no tree (it was removed, or
+     * never placed). They change the object and emit nothing.
+     */
+    detachedWrites: number;
 };
 export declare function getProxyStats(): {
     pathConcatCacheSize: number;
@@ -30,14 +38,13 @@ export declare function getProxyStats(): {
     objects: number;
     /** Number of old proxied values evicted when replaced via set trap */
     staleEvicted: number;
+    /**
+     * Writes through a proxy whose object is in no tree (it was removed, or
+     * never placed). They change the object and emit nothing.
+     */
+    detachedWrites: number;
 };
 export declare function resetProxyStats(): void;
-/**
- * Recursively evict an object and all its nested children from proxy caches.
- * This allows GC to collect the entire old object tree when a property is
- * replaced, not just the top-level value.
- */
-export declare function evictDeep(value: any): void;
 export declare function deepEqual(a: any, b: any, seen?: WeakMap<any, any>): boolean;
 export declare function getFromPathCache(root: object, pathKey: string): any | undefined;
 export declare function setInPathCache(root: object, pathKey: string, value: any): void;
@@ -47,14 +54,148 @@ export declare function setInPathCache(root: object, pathKey: string, value: any
  * (and any deeper ones) are not reused on subsequent mutations.
  */
 export declare function evictDescendantsFromPathCache(root: object, pathKey: string): void;
-export declare function getPathConcat(path: string): any[] | undefined;
-export declare function setPathConcat(path: string, value: any[]): void;
 /**
  * recursively traverses an object or array, accessing each property/element.
  * used by `watch` with `deep: true` to establish dependencies on all nested properties.
  * the actual tracking is done by the proxy `get` handlers triggered during traversal.
  */
 export declare function traverse(value: any, seen?: Set<any>): any;
+/**
+ * The most copies one snapshot may make beyond the first copy of each
+ * object. A snapshot copies a shared object once per place, so a graph
+ * that shares objects at many places (each level holding the one below
+ * twice) grows exponentially: 22 objects become 4,194,303 copies. Such a
+ * snapshot throws a `RangeError` instead. A tree, however large, makes no
+ * extra copies and is never refused.
+ */
+export declare const SNAPSHOT_SHARED_COPY_LIMIT = 100000;
+/** A snapshot over `SNAPSHOT_SHARED_COPY_LIMIT`. */
+export declare class SnapshotLimitError extends RangeError {
+    constructor(extraCopies: number);
+}
+/**
+ * A write the library cannot synchronize, refused before anything changed.
+ * See "Supported inputs" under "Synchronization Limits" in the README.
+ */
+export declare class UnsupportedStateError extends TypeError {
+    constructor(problem: string);
+}
+/**
+ * Which arrays of a payload copy keep their named (non-index) properties.
+ * Finding them costs a key list per array, so only the payloads 1.0.44 sent
+ * as the value itself keep them: the initial replace, inserted values and
+ * what a write removes. Reorders also keep properties below the reordered
+ * array. Assignment `newValue` copies keep array items only, as in 1.0.44.
+ */
+export declare const enum Named {
+    /** No array: its items only. */
+    None = 0,
+    /** Arrays below `items`, `oldValues`, or the reordered array. */
+    Below = 1,
+    /** Every array. */
+    All = 2
+}
+/**
+ * Deep clone for event payloads. Unlike `deepClone`, an object that appears
+ * at several places in `value` is copied once per place, so the result is a
+ * tree: a replica holds one copy per place, and a write through a shared
+ * object emits one event per place. Copies may not share objects, because a
+ * wire that keeps identity (structuredClone, an in-process listener) would
+ * then hold one object where the source has several places, and apply each
+ * per-place event to it again. Cycles are kept. Every own enumerable data
+ * property is copied as an own data property (also `__proto__`), and an
+ * array's holes stay holes; `named` says which arrays keep their named
+ * properties. Levels deeper than `FILL_DEPTH` take no stack frame, so any
+ * depth fits.
+ *
+ * Throws a `SnapshotLimitError` (a `RangeError`) when the copy would make more than
+ * `SNAPSHOT_SHARED_COPY_LIMIT` extra copies of shared objects.
+ */
+export declare function cloneTree<T>(value: T, named: Named): T;
+/** What `cloneTreeUnless` returns for a value that reaches the object it names. */
+export declare const REACHES: unique symbol;
+/**
+ * `cloneTree(value, named)`, or `REACHES` as soon as the copy (or its
+ * measure) meets `container`. A `SnapshotLimitError` thrown first is
+ * measured on objects other than `container`.
+ */
+export declare function cloneTreeUnless<T>(value: T, container: object, named: Named): T | typeof REACHES;
+/**
+ * `cloneTreeUnless(value, container, named)` for a value about to be stored
+ * (the new value of a write, inserted items, a new root; `container` may be
+ * undefined). It also finds whether the value is fresh: no object in it has
+ * a location node, and no object sits at two places in it (an alias or a
+ * cycle). `copiedFresh` says so when the call returns. The place walk of a
+ * store finds nothing to do in a fresh value, so the store skips it (see
+ * `attachValue`). The check stops at the first object that is not fresh.
+ */
+export declare function cloneStored<T>(value: T, container: object | undefined, named: Named): T | typeof REACHES;
+/** Whether the value the last `cloneStored` call copied is fresh; set when it returns. */
+export declare let copiedFresh: boolean;
+/**
+ * The copy `cloneTree(value, named)` makes once `container` holds what
+ * `contents` holds: wherever the copy (and its measure) meets `container`,
+ * it reads `contents` instead, a shallow copy of `container` of the same
+ * kind. So a payload is copied, or refused, as it will be after a write to
+ * `container`, before that write is made.
+ */
+export declare function cloneTreeAfter<T>(value: T, container: object, contents: object, named: Named): T;
+/**
+ * The enumerable string and symbol keys of `array` other than indexes.
+ * Indexes come first among string keys. Undefined when no keys remain.
+ */
+export declare function namedKeys(array: object): (string | symbol)[] | undefined;
+/** `object[key] = value` as an own enumerable data property: no setter runs, and `__proto__` stays a key. */
+export declare function setData(object: object, key: PropertyKey, value: unknown): void;
+/**
+ * Name `member`, a member of `collection` (raw), in a payload whose copy of
+ * it is `copy`, or `member` itself when the event sends the object.
+ * `entering`: the write puts `member` into `collection`. Returns what the
+ * payload carries: `copy`, or a copy that carries the token `member` has in
+ * `collection` when that is not its own token (see `overrides`). Inside a
+ * copy of a payload (see `copyingPayload`), `member` is itself a copy, and
+ * `copy` names the same member.
+ */
+export declare function nameMember(member: unknown, copy: unknown, collection: object, entering: boolean): unknown;
+/**
+ * Name `key`, a key of `collection` (raw), in the map event `event`, which
+ * carries the key itself, or a copy when its token there is not its own
+ * (see `nameMember`). `entering`: the write adds `key`.
+ */
+export declare function nameKey(event: StateEvent, key: object, collection: object, entering: boolean): void;
+/** `copy` is a copy of the payload copy `source`: it names the same member. */
+export declare function nameCopyOfCopy(source: unknown, copy: unknown): void;
+/** Copy payloads of payloads with `run` (see `copyingPayload`). */
+export declare function copyingPayloads<T>(run: () => T): T;
+/** What the proxy of a Set or Map reads to know whether its collection has an index (see `watchIndex`). */
+export interface IndexWatch {
+    indexed: boolean;
+}
+/**
+ * The `IndexWatch` for a new proxy of `collection` (raw): `indexed` turns
+ * true when the collection gets an index, also one `updateState` made
+ * before the proxy, and the proxy then keeps that index as it changes the
+ * collection (see `indexAdded`).
+ */
+export declare function watchIndex(collection: object): IndexWatch;
+/**
+ * The proxy of `collection` (raw), which has an index (see
+ * `watchIndex`), added `member` (a Set member or Map key): the
+ * index takes it, so a later event finds it without a rebuild.
+ */
+export declare function indexAdded(collection: Set<unknown> | Map<unknown, unknown>, member: unknown): void;
+/** The proxy of `collection` (raw), which has an index, removed `member`: the index lets it go. */
+export declare function indexRemoved(collection: Set<unknown> | Map<unknown, unknown>, member: unknown): void;
+/** `set-add` on a replica set (raw or a proxy). */
+export declare function replicaAdd(set: Set<unknown>, value: unknown): void;
+/** `set-delete` on a replica set (raw or a proxy). */
+export declare function replicaDelete(set: Set<unknown>, value: unknown): void;
+/** `map-set` on a replica map (raw or a proxy). */
+export declare function replicaMapSet(map: Map<unknown, unknown>, key: unknown, value: unknown): void;
+/** `map-delete` on a replica map (raw or a proxy). */
+export declare function replicaMapDelete(map: Map<unknown, unknown>, key: unknown): void;
+/** A replica collection was cleared or refilled: its index is made again when needed. */
+export declare function forgetReplicaIndex(collection: object): void;
 /**
  * creates a deep clone of a value.
  * includes cycle detection using a weakmap.

package/dist/wrap-array.d.ts

@@ -1,2 +1,2 @@
-import { EmitFunction, Path } from "./types";
-export declare function wrapArray<T extends any[]>(arr: T, emit?: EmitFunction, path?: Path): T;
+import { LocationNode } from "./location";
+export declare function wrapArray<T extends any[]>(arr: T, node: LocationNode): T;

package/dist/wrap-map.d.ts

@@ -1,2 +1,2 @@
-import { EmitFunction, Path } from "./types";
-export declare function wrapMap<K, V>(map: Map<K, V>, emit?: EmitFunction, path?: Path): Map<K, V>;
+import { LocationNode } from "./location";
+export declare function wrapMap<K, V>(map: Map<K, V>, node: LocationNode): Map<K, V>;

package/dist/wrap-set.d.ts

@@ -1,2 +1,2 @@
-import { EmitFunction, Path } from "./types";
-export declare function wrapSet<T>(set: Set<T>, emit?: EmitFunction, path?: Path): Set<T>;
+import { LocationNode } from "./location";
+export declare function wrapSet<T>(set: Set<T>, node: LocationNode): Set<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yiin/reactive-proxy-state",
-  "version": "1.0.44",
+  "version": "2.0.0",
   "author": "Yiin <stanislovas@yiin.lt>",
   "repository": {
     "type": "git",