j-templates 8.1.2 → 9.0.0

package/Store/Tree/observableNode.d.ts

@@ -48,16 +48,7 @@ export declare namespace ObservableNode {
      * @returns The snapshot, or `undefined` if `proxy` is not an observable node.
      */
     function Snapshot<T>(proxy: T): T | undefined;
-    /**
-     * Marks an observable node or its property as changed, triggering reactive updates.
-     * Used internally to notify dependencies that a value has been modified.
-     * @param value The observable node to touch.
-     * @param prop Optional property name or index to touch a specific nested property.
-     */
-    function Update<T>(value: T, prop?: keyof T): void;
-    function Assign<T>(value: T, prop: keyof T, propValue: any): void;
     function Touch<T>(value: T, prop?: keyof T): void;
-    function Read<T>(value: T, prop: keyof T): void;
     /**
      * Merges a new value into an observable node in-place, preserving the node's object identity.
      * Computes the diff between the node's current value and the provided value, then applies only
@@ -77,26 +68,14 @@ export declare namespace ObservableNode {
      * @remarks No-op when `value` deep-equals the node's current value (empty diff).
      */
     function Apply(rootNode: any, value: any): void;
-    /**
-     * Splices an observable node's underlying array in-place, invalidating its snapshot and
-     * touching its scope so reactive readers update.
-     * @param rootNode The observable array node to splice.
-     * @param start Index at which to start changing the array.
-     * @param deleteCount Number of elements to remove starting at `start`.
-     * @param items Elements to insert at `start`.
-     * @param cloneData Whether to deep-clone `items` before inserting them (true by default,
-     *   so the store isn't left holding a reference the caller can still mutate).
-     */
-    function ApplySplice(rootNode: any, start: number, deleteCount: number, items: any[], cloneData?: boolean): void;
     /**
      * Applies a JSON diff result to an observable node, efficiently updating only changed properties.
      * Optimizes nested object updates by computing paths incrementally and touching modified properties.
      * @param rootNode The observable node to apply the diff to.
      * @param diffResult The diff result from JsonDiff containing path-value pairs of changes.
-     * @param cloneData Whether to deep-clone each diff value before writing it in (true by
-     *   default), so the store isn't left holding a reference the caller can still mutate.
+     *   Each value is deep-cloned as it's applied (see JsonApplyDiff).
      */
-    function ApplyDiff(rootNode: any, diffResult: JsonDiffResult, cloneData?: boolean): void;
+    function ApplyDiff(rootNode: any, diffResult: JsonDiffResult): void;
     /**
      * Creates a factory function for making values observable with optional aliasing.
      * The alias function transforms values before creating the observable proxy,

package/Store/Tree/observableNode.js

@@ -1,9 +1,11 @@
-import { JsonDeepClone, JsonDiff } from "../../Utils/json";
+import { JsonApplyDiff, JsonDeepClone, JsonDiff } from "../../Utils/json";
 import { JsonType } from "../../Utils/json";
 import { ObservableScope } from "./observableScope";
+import { Snapshot } from "./snapshot";
 const NODE_VALUE = Symbol("NODE_VALUE");
 const NODE_PROXY = Symbol("NODE_PROXY");
 const NODE_SNAPSHOT = Symbol("NODE_SNAPSHOT");
+const NODE_WRAPPER = Symbol("NODE_WRAPPER");
 const toJSON = "toJSON";
 const IS_NODE = Symbol("IS_NODE");
 const ARRAY_SCOPE = Symbol("ARRAY_SCOPE");
@@ -15,23 +17,9 @@ function Property(value, prop) {
     return value[prop];
 }
 const wrapperCache = new WeakMap();
-const valueSnapshotCache = new WeakMap();
-const valueSnapshotHierarchy = new WeakMap();
-function CreateSnapshotLink(child, parent) {
-    let parents = valueSnapshotHierarchy.get(child);
-    if (!parents)
-        valueSnapshotHierarchy.set(child, (parents = new Set()));
-    parents.add(parent);
-}
+const snapshotState = Snapshot.Create();
 function InvalidateSnapshotForValue(value) {
-    valueSnapshotCache.delete(value);
-    const parents = valueSnapshotHierarchy.get(value);
-    if (parents === undefined)
-        return;
-    valueSnapshotHierarchy.delete(value);
-    for (const parent of parents)
-        if (valueSnapshotCache.has(parent))
-            InvalidateSnapshotForValue(parent);
+    Snapshot.Invalidate(snapshotState, value);
 }
 function getOwnPropertyDescriptor(target, prop) {
     ObservableScope.Touch(target[OBJECT_SCOPE]);
@@ -109,10 +97,8 @@ function CloneProxy(value, type = JsonType(value)) {
     }
     return value;
 }
-function GetPropertyScope(object, prop, create = true) {
+function GetPropertyScope(object, prop) {
     if (!Object.hasOwn(object, prop)) {
-        if (!create)
-            return undefined;
         Object.defineProperty(object, prop, {
             value: ObservableScope.Basic(Property.bind(null, object[NODE_VALUE], prop)),
             writable: true,
@@ -123,64 +109,45 @@ function GetPropertyScope(object, prop, create = true) {
     return object[prop];
 }
 function SetObjectValue(object, prop, value) {
-    const propExists = Object.hasOwn(object[NODE_VALUE], prop);
-    object[NODE_VALUE][prop] = value;
-    InvalidateSnapshotForValue(object[NODE_VALUE]);
-    Object.hasOwn(object, prop) && ObservableScope.Update(object[prop]);
-    !propExists && ObservableScope.Update(object[OBJECT_SCOPE]);
+    AssignNodeValue(object[NODE_VALUE], prop, value, object);
 }
 function SetArrayValue(object, prop, value) {
     object[NODE_VALUE][prop] = value;
-    InvalidateSnapshotForValue(object[NODE_VALUE]);
-    ObservableScope.Update(object[ARRAY_SCOPE]);
+    NodeValueSet(object[NODE_VALUE], prop, false, object);
+}
+function NodeValueSet(obj, prop, added, wrapper = wrapperCache.get(obj)) {
+    InvalidateSnapshotForValue(obj);
+    if (!wrapper)
+        return;
+    // An array's wrapper is an array with no property scopes: its own `length` isn't one, and a
+    // diff that only shrinks an array writes nothing but `length`
+    const propScopeExists = !!prop && !wrapper[ARRAY_SCOPE] && Object.hasOwn(wrapper, prop);
+    if (!prop || added || !propScopeExists)
+        ObservableScope.Update(wrapper[ARRAY_SCOPE] ?? wrapper[OBJECT_SCOPE]);
+    if (propScopeExists)
+        ObservableScope.Update(wrapper[prop]);
+}
+/** A deleted property: the object's keys changed, so its scope updates, and so does the property's. */
+function RemoveNodeValue(obj, prop) {
+    delete obj[prop];
+    NodeValueSet(obj, prop, true);
+}
+/** An array spliced in place: its elements changed, so its scope updates. Moved elements keep their nodes. */
+function SplicedNodeValue(array) {
+    NodeValueSet(array, "", false);
+}
+/** A property assigned: the object's scope updates when it's new, and the property's does */
+function AssignNodeValue(obj, prop, value, wrapper) {
+    const added = !Object.hasOwn(obj, prop);
+    obj[prop] = value;
+    NodeValueSet(obj, prop, added, wrapper);
 }
 function CreateProxyFactory(alias) {
-    /**
-     * An immutable snapshot of a raw node value (arrays and plain objects; other values are
-     * returned as they are). A snapshot is cached per raw value in valueSnapshotCache and
-     * returned as-is until a write invalidates it: every write path calls Invalidate, which
-     * clears the written value and every cached ancestor, found through the parent links
-     * recorded here. A rebuild makes new containers but reuses the cached snapshots of
-     * unchanged children, so a snapshot handed out never changes and unchanged parts are
-     * shared between snapshots. Keyed children are read through their root.
-     */
+    // Keyed children are read through their root. Every factory shares the module-level
+    // snapshotState, matching wrapperCache; only the resolver differs per factory.
+    const resolveSnapshot = alias && (child => alias(child, false));
     function CreateSnapshot(value) {
-        if (JsonType(value) === "value")
-            return value;
-        const cached = valueSnapshotCache.get(value);
-        if (cached !== undefined)
-            return cached;
-        let snapshot;
-        if (Array.isArray(value)) {
-            snapshot = new Array(value.length);
-            for (let x = 0; x < value.length; x++)
-                snapshot[x] = ChildSnapshot(value, value[x]);
-        }
-        else {
-            snapshot = {};
-            const keys = Object.keys(value);
-            for (let x = 0; x < keys.length; x++)
-                snapshot[keys[x]] = ChildSnapshot(value, value[keys[x]]);
-        }
-        valueSnapshotCache.set(value, snapshot);
-        return snapshot;
-    }
-    /**
-     * A child's snapshot, linking the child to its parent so a write to the child
-     * invalidates the parent. A keyed child's snapshot comes from its root, so the root is
-     * linked too; the parent's own embedded copy stays linked because a positional write
-     * (one that changes which entity a slot holds) mutates that copy in place.
-     */
-    function ChildSnapshot(parent, child) {
-        if (JsonType(child) === "value")
-            return child;
-        CreateSnapshotLink(child, parent);
-        const resolved = alias?.(child, false);
-        if (resolved !== undefined && resolved !== child) {
-            CreateSnapshotLink(resolved, parent);
-            return CreateSnapshot(resolved);
-        }
-        return CreateSnapshot(child);
+        return Snapshot.Get(snapshotState, value, resolveSnapshot);
     }
     const readOnly = alias !== undefined;
     function CreateArrayProxy(value) {
@@ -225,6 +192,8 @@ function CreateProxyFactory(alias) {
                 return function () {
                     return CreateSnapshot(object[NODE_VALUE]);
                 };
+            case NODE_WRAPPER:
+                return object;
             case NODE_VALUE:
                 return object[NODE_VALUE];
             case NODE_SNAPSHOT:
@@ -290,6 +259,8 @@ function CreateProxyFactory(alias) {
         switch (prop) {
             case IS_NODE:
                 return true;
+            case NODE_WRAPPER:
+                return object;
             case NODE_SNAPSHOT:
                 return CreateSnapshot(object[NODE_VALUE]);
             case toJSON:
@@ -404,36 +375,6 @@ export var ObservableNode;
         return undefined;
     }
     ObservableNode.Snapshot = Snapshot;
-    /**
-     * Marks an observable node or its property as changed, triggering reactive updates.
-     * Used internally to notify dependencies that a value has been modified.
-     * @param value The observable node to touch.
-     * @param prop Optional property name or index to touch a specific nested property.
-     */
-    function Update(value, prop) {
-        const wrapper = wrapperCache.get(value);
-        if (wrapper) {
-            const scope = Array.isArray(wrapper) ? wrapper[ARRAY_SCOPE] : (prop && GetPropertyScope(wrapper, prop)) ?? wrapper[OBJECT_SCOPE];
-            ObservableScope.Update(scope);
-        }
-    }
-    ObservableNode.Update = Update;
-    function Assign(value, prop, propValue) {
-        // const propExists = Object.hasOwn(value as Object, prop);
-        // value[prop] = propValue;
-        const wrapper = wrapperCache.get(value);
-        if (wrapper) {
-            if (Array.isArray(wrapper))
-                SetArrayValue(wrapper, prop, propValue);
-            else
-                SetObjectValue(wrapper, prop, propValue);
-        }
-        else {
-            InvalidateSnapshotForValue(value);
-            value[prop] = propValue;
-        }
-    }
-    ObservableNode.Assign = Assign;
     function Touch(value, prop) {
         const wrapper = wrapperCache.get(value);
         if (wrapper) {
@@ -442,14 +383,6 @@ export var ObservableNode;
         }
     }
     ObservableNode.Touch = Touch;
-    function Read(value, prop) {
-        const wrapper = wrapperCache.get(value);
-        if (wrapper) {
-            const scope = Array.isArray(wrapper) ? wrapper[ARRAY_SCOPE] : (prop && wrapper[prop]) ?? wrapper[OBJECT_SCOPE];
-            ObservableScope.Update(scope);
-        }
-    }
-    ObservableNode.Read = Read;
     /**
      * Merges a new value into an observable node in-place, preserving the node's object identity.
      * Computes the diff between the node's current value and the provided value, then applies only
@@ -474,86 +407,16 @@ export var ObservableNode;
         ApplyDiff(rootNode, diff);
     }
     ObservableNode.Apply = Apply;
-    /**
-     * Splices an observable node's underlying array in-place, invalidating its snapshot and
-     * touching its scope so reactive readers update.
-     * @param rootNode The observable array node to splice.
-     * @param start Index at which to start changing the array.
-     * @param deleteCount Number of elements to remove starting at `start`.
-     * @param items Elements to insert at `start`.
-     * @param cloneData Whether to deep-clone `items` before inserting them (true by default,
-     *   so the store isn't left holding a reference the caller can still mutate).
-     */
-    function ApplySplice(rootNode, start, deleteCount, items, cloneData = true) {
-        const root = rootNode[NODE_VALUE];
-        InvalidateSnapshotForValue(rootNode[NODE_VALUE]);
-        const addItems = cloneData ? JsonDeepClone(items) : items;
-        root.splice(start, deleteCount, ...addItems);
-        ObservableNode.Update(root);
-    }
-    ObservableNode.ApplySplice = ApplySplice;
     /**
      * Applies a JSON diff result to an observable node, efficiently updating only changed properties.
      * Optimizes nested object updates by computing paths incrementally and touching modified properties.
      * @param rootNode The observable node to apply the diff to.
      * @param diffResult The diff result from JsonDiff containing path-value pairs of changes.
-     * @param cloneData Whether to deep-clone each diff value before writing it in (true by
-     *   default), so the store isn't left holding a reference the caller can still mutate.
+     *   Each value is deep-cloned as it's applied (see JsonApplyDiff).
      */
-    function ApplyDiff(rootNode, diffResult, cloneData = true) {
+    function ApplyDiff(rootNode, diffResult) {
         const root = rootNode[NODE_VALUE];
-        if (diffResult.length === 1 && diffResult[0].path.length === 0) {
-            // Replacing rootNode
-            InvalidateSnapshotForValue(root);
-            const rootPatch = cloneData ? JsonDeepClone(diffResult[0].value) : diffResult[0].value;
-            const rootType = JsonType(root);
-            const rootPatchType = JsonType(rootPatch);
-            if (rootType !== rootPatchType)
-                throw new Error("Unable to change type of Root ObservableNode: " + rootType);
-            switch (rootType) {
-                case "array": {
-                    root.splice(0, root.length, ...rootPatch);
-                    ObservableNode.Update(root);
-                    break;
-                }
-                case "object": {
-                    const keys = Object.keys(root);
-                    const patchKeys = Object.keys(rootPatch);
-                    for (let x = 0; x < keys.length; x++)
-                        if (!patchKeys.includes(keys[x]))
-                            delete root[keys[x]];
-                    Object.assign(root, rootPatch);
-                    for (let x = 0; x < keys.length; x++)
-                        ObservableNode.Update(root, keys[x]);
-                    break;
-                }
-                case "value":
-                    throw new Error("Unable to replace value type: " + root);
-            }
-            return;
-        }
-        const pathTuples = [["", root]];
-        for (let x = 0; x < diffResult.length; x++) {
-            const { path, value } = diffResult[x];
-            let y = 0;
-            for (; y < path.length - 1; y++) {
-                const property = path[y];
-                const value = pathTuples[y][1];
-                const tupleIndex = y + 1;
-                if (pathTuples.length <= tupleIndex)
-                    pathTuples.push([property, value[property]]);
-                else if (pathTuples[tupleIndex][0] !== property) {
-                    pathTuples[tupleIndex][0] = property;
-                    pathTuples[tupleIndex][1] = value[property];
-                    const next = tupleIndex + 1;
-                    if (next < pathTuples.length)
-                        pathTuples[next][0] = null;
-                }
-            }
-            const assignValue = pathTuples[y][1];
-            const assignData = cloneData ? JsonDeepClone(value) : value;
-            ObservableNode.Assign(assignValue, path[y], assignData);
-        }
+        JsonApplyDiff(root, diffResult, AssignNodeValue, RemoveNodeValue, SplicedNodeValue);
     }
     ObservableNode.ApplyDiff = ApplyDiff;
     /**

package/Store/Tree/snapshot.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Resolves a keyed child to the root entity it should be read through. Returns the entity, or
+ * undefined when the child isn't keyed (or has no root), in which case the child itself is used.
+ */
+export type SnapshotResolver = (child: any) => object | undefined;
+/**
+ * Snapshot cache state. Each owner (a `DiffTree` instance, or `ObservableNode` at module
+ * level) creates its own state, so cached snapshots are never shared between owners.
+ */
+export interface ISnapshotState {
+    /** Raw value -> its cached immutable snapshot */
+    rawToSnapshotCache: WeakMap<object, any>;
+    /** Raw value -> every parent whose cached snapshot embedded it */
+    hierarchy: WeakMap<object, Set<object>>;
+}
+export declare namespace Snapshot {
+    /**
+     * Creates a new, empty snapshot cache.
+     * @returns A new snapshot state.
+     */
+    function Create(): ISnapshotState;
+    /**
+     * Returns an immutable, cached snapshot of a raw value. The same snapshot is returned
+     * until a write invalidates it, and unchanged nested parts are shared between snapshots,
+     * so `===` holds for any part that hasn't changed.
+     * @param state The snapshot cache to read from and populate.
+     * @param value The raw value to snapshot.
+     * @param resolve Resolver for keyed children. Snapshots are cached per raw value, so a value
+     * must always be read with the same resolver.
+     * @returns The snapshot.
+     */
+    function Get<T>(state: ISnapshotState, value: T, resolve?: SnapshotResolver): T;
+    /**
+     * The snapshot of one property of a raw value, as the value's own snapshot would hold it:
+     * cached, keyed children read through their root, and linked to the value so a write to the
+     * property invalidates the value's snapshot. Reads one property without building a snapshot of
+     * the whole value.
+     * @param state The snapshot cache to read from and populate.
+     * @param parent The raw value the property is on.
+     * @param key The property.
+     * @param resolve Resolver for keyed children.
+     * @returns The property's snapshot.
+     */
+    function Child(state: ISnapshotState, parent: any, key: string | number, resolve?: SnapshotResolver): any;
+    /**
+     * Invalidates the cached snapshot of a raw value that was just written to, along with
+     * every cached ancestor that embedded it.
+     * @param state The snapshot cache to invalidate.
+     * @param value The raw value that was written to.
+     */
+    function Invalidate(state: ISnapshotState, value: object): void;
+    /**
+     * The cached snapshot of a raw value, without building one. A write to the value, or to
+     * anything its snapshot embeds, clears the cache, so a reader that kept the snapshot it got
+     * can tell nothing under the value changed when this returns that same snapshot.
+     * @param state The snapshot cache.
+     * @param value The raw value.
+     * @returns The cached snapshot, or undefined when there's none.
+     */
+    function Peek<T>(state: ISnapshotState, value: T): T | undefined;
+    /**
+     * Registers a value as its own snapshot. Use in a case where an immutable value can
+     * represent itself as a valid snapshot without cloning.
+     * @param state The snapshot cache.
+     * @param value The raw value that is its own snapshot.
+     */
+    function Register(state: ISnapshotState, value: object): void;
+}

package/Store/Tree/snapshot.js

@@ -0,0 +1,147 @@
+import { JsonType } from "../../Utils/json";
+function CreateSnapshotLink(state, child, parent) {
+    let parents = state.hierarchy.get(child);
+    if (!parents)
+        state.hierarchy.set(child, (parents = new Set()));
+    parents.add(parent);
+}
+/**
+ * Clears the cached snapshot for a raw value that was just written to, and climbs to
+ * every parent whose own cached snapshot embedded it, so a write to a deeply nested value
+ * invalidates every cached ancestor that still holds a snapshot.
+ */
+function InvalidateValue(state, value) {
+    state.rawToSnapshotCache.delete(value);
+    const parents = state.hierarchy.get(value);
+    if (parents === undefined)
+        return;
+    state.hierarchy.delete(value);
+    for (const parent of parents)
+        if (state.rawToSnapshotCache.has(parent))
+            InvalidateValue(state, parent);
+}
+/**
+ * An immutable snapshot of a raw value (arrays and plain objects; other values are
+ * returned as they are). A snapshot is cached per raw value and returned as-is until a
+ * write invalidates it. A rebuild makes new containers but reuses the cached snapshots of
+ * unchanged children, so a snapshot handed out never changes and unchanged parts are
+ * shared between snapshots. Keyed children are read through their root.
+ */
+function CreateSnapshot(state, resolve, value) {
+    if (JsonType(value) === "value")
+        return value;
+    const cached = state.rawToSnapshotCache.get(value);
+    if (cached !== undefined)
+        return cached;
+    let snapshot;
+    if (Array.isArray(value)) {
+        snapshot = new Array(value.length);
+        for (let x = 0; x < value.length; x++)
+            snapshot[x] = ChildSnapshot(state, resolve, value, x);
+    }
+    else {
+        snapshot = {};
+        const keys = Object.keys(value);
+        for (let x = 0; x < keys.length; x++)
+            snapshot[keys[x]] = ChildSnapshot(state, resolve, value, keys[x]);
+    }
+    state.rawToSnapshotCache.set(value, snapshot);
+    return snapshot;
+}
+/**
+ * A child's snapshot, linking the child to its parent so a write to the child
+ * invalidates the parent. A keyed child's snapshot comes from its root, so the root is
+ * linked too; the parent's own embedded copy stays linked because a positional write
+ * (one that changes which entity a slot holds) mutates that copy in place.
+ */
+function ChildSnapshot(state, resolve, parent, key) {
+    const child = parent[key];
+    if (JsonType(child) === "value")
+        return child;
+    CreateSnapshotLink(state, child, parent);
+    const resolved = resolve?.(child);
+    if (resolved !== undefined && resolved !== child) {
+        CreateSnapshotLink(state, resolved, parent);
+        return CreateSnapshot(state, resolve, resolved);
+    }
+    return CreateSnapshot(state, resolve, child);
+}
+function RegisterSnapshot(state, snapshot) {
+    if (JsonType(snapshot) !== 'value')
+        state.rawToSnapshotCache.set(snapshot, snapshot);
+}
+export var Snapshot;
+(function (Snapshot) {
+    /**
+     * Creates a new, empty snapshot cache.
+     * @returns A new snapshot state.
+     */
+    function Create() {
+        return {
+            rawToSnapshotCache: new WeakMap(),
+            hierarchy: new WeakMap(),
+        };
+    }
+    Snapshot.Create = Create;
+    /**
+     * Returns an immutable, cached snapshot of a raw value. The same snapshot is returned
+     * until a write invalidates it, and unchanged nested parts are shared between snapshots,
+     * so `===` holds for any part that hasn't changed.
+     * @param state The snapshot cache to read from and populate.
+     * @param value The raw value to snapshot.
+     * @param resolve Resolver for keyed children. Snapshots are cached per raw value, so a value
+     * must always be read with the same resolver.
+     * @returns The snapshot.
+     */
+    function Get(state, value, resolve) {
+        return CreateSnapshot(state, resolve, value);
+    }
+    Snapshot.Get = Get;
+    /**
+     * The snapshot of one property of a raw value, as the value's own snapshot would hold it:
+     * cached, keyed children read through their root, and linked to the value so a write to the
+     * property invalidates the value's snapshot. Reads one property without building a snapshot of
+     * the whole value.
+     * @param state The snapshot cache to read from and populate.
+     * @param parent The raw value the property is on.
+     * @param key The property.
+     * @param resolve Resolver for keyed children.
+     * @returns The property's snapshot.
+     */
+    function Child(state, parent, key, resolve) {
+        return ChildSnapshot(state, resolve, parent, key);
+    }
+    Snapshot.Child = Child;
+    /**
+     * Invalidates the cached snapshot of a raw value that was just written to, along with
+     * every cached ancestor that embedded it.
+     * @param state The snapshot cache to invalidate.
+     * @param value The raw value that was written to.
+     */
+    function Invalidate(state, value) {
+        InvalidateValue(state, value);
+    }
+    Snapshot.Invalidate = Invalidate;
+    /**
+     * The cached snapshot of a raw value, without building one. A write to the value, or to
+     * anything its snapshot embeds, clears the cache, so a reader that kept the snapshot it got
+     * can tell nothing under the value changed when this returns that same snapshot.
+     * @param state The snapshot cache.
+     * @param value The raw value.
+     * @returns The cached snapshot, or undefined when there's none.
+     */
+    function Peek(state, value) {
+        return state.rawToSnapshotCache.get(value);
+    }
+    Snapshot.Peek = Peek;
+    /**
+     * Registers a value as its own snapshot. Use in a case where an immutable value can
+     * represent itself as a valid snapshot without cloning.
+     * @param state The snapshot cache.
+     * @param value The raw value that is its own snapshot.
+     */
+    function Register(state, value) {
+        RegisterSnapshot(state, value);
+    }
+    Snapshot.Register = Register;
+})(Snapshot || (Snapshot = {}));