reactronic 0.22.302 → 0.22.303

package/build/dist/source/impl/Transaction.js

@@ -12,7 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transaction = void 0;
 const Utils_1 = require("../util/Utils");
 const Dbg_1 = require("../util/Dbg");
-const Snapshot_1 = require("./Snapshot");
+const Changeset_1 = require("./Changeset");
 class Transaction {
     static get current() { return TransactionImpl.current; }
     whenFinished() {
@@ -31,7 +31,7 @@ class TransactionImpl extends Transaction {
     constructor(options) {
         super();
         this.margin = TransactionImpl.curr !== undefined ? TransactionImpl.curr.margin + 1 : -1;
-        this.snapshot = new Snapshot_1.Snapshot(options);
+        this.changeset = new Changeset_1.Changeset(options);
         this.pending = 0;
         this.sealed = false;
         this.canceled = undefined;
@@ -41,10 +41,10 @@ class TransactionImpl extends Transaction {
         this.reject = Utils_1.UNDEF;
     }
     static get current() { return TransactionImpl.curr; }
-    get id() { return this.snapshot.id; }
-    get hint() { return this.snapshot.hint; }
-    get options() { return this.snapshot.options; }
-    get timestamp() { return this.snapshot.timestamp; }
+    get id() { return this.changeset.id; }
+    get hint() { return this.changeset.hint; }
+    get options() { return this.changeset.options; }
+    get timestamp() { return this.changeset.timestamp; }
     get error() { return this.canceled; }
     run(func, ...args) {
         this.guard();
@@ -181,8 +181,8 @@ class TransactionImpl extends Transaction {
                         const options = {
                             hint: `${this.hint} - restart after T${this.after.id}`,
                             standalone: this.options.standalone === 'isolated' ? 'isolated' : true,
-                            logging: this.snapshot.options.logging,
-                            token: this.snapshot.options.token,
+                            logging: this.changeset.options.logging,
+                            token: this.changeset.options.token,
                         };
                         return TransactionImpl.run(options, func, ...args);
                     }
@@ -211,7 +211,7 @@ class TransactionImpl extends Transaction {
             }
             TransactionImpl.curr = this;
             this.pending++;
-            this.snapshot.acquire(outer.snapshot);
+            this.changeset.acquire(outer.changeset);
             result = func(...args);
             if (this.sealed && this.pending === 1) {
                 if (!this.canceled)
@@ -230,7 +230,7 @@ class TransactionImpl extends Transaction {
             if (this.sealed && this.pending === 0) {
                 const reactions = this.applyOrDiscard();
                 TransactionImpl.curr = outer;
-                TransactionImpl.off(Snapshot_1.Snapshot.enqueueReactionsToRun, reactions);
+                TransactionImpl.off(Changeset_1.Changeset.enqueueReactionsToRun, reactions);
             }
             else
                 TransactionImpl.curr = outer;
@@ -246,25 +246,25 @@ class TransactionImpl extends Transaction {
                 if (after && after !== TransactionImpl.none)
                     Dbg_1.Log.write('║', ' [!]', `T${t.id}[${t.hint}] will be restarted${t !== after ? ` after T${after.id}[${after.hint}]` : ''}`);
             }
-            Snapshot_1.Snapshot.revokeAllSubscriptions(t.snapshot);
+            Changeset_1.Changeset.revokeAllSubscriptions(t.changeset);
         }
         t.sealed = true;
     }
     checkForConflicts() {
-        const conflicts = this.snapshot.rebase();
+        const conflicts = this.changeset.rebase();
         if (conflicts)
             this.tryResolveConflicts(conflicts);
     }
     tryResolveConflicts(conflicts) {
-        throw (0, Dbg_1.error)(`T${this.id}[${this.hint}] conflicts with: ${Snapshot_1.Dump.conflicts(conflicts)}`, undefined);
+        throw (0, Dbg_1.error)(`T${this.id}[${this.hint}] conflicts with: ${Changeset_1.Dump.conflicts(conflicts)}`, undefined);
     }
     applyOrDiscard() {
         let reactions;
         try {
             if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
                 Dbg_1.Log.write('╠═', '', '', undefined, 'changes');
-            reactions = this.snapshot.applyOrDiscard(this.canceled);
-            this.snapshot.triggerGarbageCollection();
+            reactions = this.changeset.applyOrDiscard(this.canceled);
+            this.changeset.triggerGarbageCollection();
             if (this.promise) {
                 if (this.canceled && !this.after)
                     this.reject(this.canceled);
@@ -289,20 +289,20 @@ class TransactionImpl extends Transaction {
         }
         return this.promise;
     }
-    static getCurrentSnapshot() {
-        return TransactionImpl.curr.snapshot;
+    static getCurrentChangeset() {
+        return TransactionImpl.curr.changeset;
     }
-    static editSnapshot() {
+    static getEditableChangeset() {
         if (TransactionImpl.inspection)
             throw (0, Dbg_1.misuse)('cannot make changes during transaction inspection');
-        return TransactionImpl.curr.snapshot;
+        return TransactionImpl.curr.changeset;
     }
     static _init() {
-        Snapshot_1.Snapshot.current = TransactionImpl.getCurrentSnapshot;
-        Snapshot_1.Snapshot.edit = TransactionImpl.editSnapshot;
+        Changeset_1.Changeset.current = TransactionImpl.getCurrentChangeset;
+        Changeset_1.Changeset.edit = TransactionImpl.getEditableChangeset;
         TransactionImpl.none.sealed = true;
-        TransactionImpl.none.snapshot.applyOrDiscard();
-        Snapshot_1.Snapshot._init();
+        TransactionImpl.none.changeset.applyOrDiscard();
+        Changeset_1.Changeset._init();
     }
 }
 TransactionImpl.none = new TransactionImpl({ hint: 'Transaction.off' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "reactronic",
-  "version": "0.22.302",
+  "version": "0.22.303",
   "description": "Reactronic - Transactional Reactive State Management",
   "main": "build/dist/source/api.js",
   "types": "build/dist/source/api.d.ts",

package/build/dist/source/impl/Snapshot.d.ts

@@ -1,60 +0,0 @@
-import { Kind, SnapshotOptions } from '../Options';
-import { AbstractSnapshot, DataRevision, MemberName, DataHolder, Subscription, Subscriber } from './Data';
-export declare const MAX_TIMESTAMP: number;
-export declare const UNDEFINED_TIMESTAMP: number;
-export declare class Snapshot implements AbstractSnapshot {
-    static idGen: number;
-    private static stampGen;
-    private static pending;
-    private static oldest;
-    static garbageCollectionSummaryInterval: number;
-    static lastGarbageCollectionSummaryTimestamp: number;
-    static totalHolderCount: number;
-    static totalRevisionCount: number;
-    readonly id: number;
-    readonly options: SnapshotOptions;
-    get hint(): string;
-    get timestamp(): number;
-    private stamp;
-    private bumper;
-    changeset: Map<DataHolder, DataRevision>;
-    reactions: Subscriber[];
-    sealed: boolean;
-    constructor(options: SnapshotOptions | null);
-    static current: () => Snapshot;
-    static edit: () => Snapshot;
-    static markUsed: (subscription: Subscription, r: DataRevision, m: MemberName, h: DataHolder, kind: Kind, weak: boolean) => void;
-    static markEdited: (oldValue: any, newValue: any, edited: boolean, r: DataRevision, m: MemberName, h: DataHolder) => void;
-    static isConflicting: (oldValue: any, newValue: any) => boolean;
-    static propagateAllChangesThroughSubscriptions: (snapshot: Snapshot) => void;
-    static revokeAllSubscriptions: (snapshot: Snapshot) => void;
-    static enqueueReactionsToRun: (reactions: Array<Subscriber>) => void;
-    seekRevision(h: DataHolder, m: MemberName): DataRevision;
-    getCurrentRevision(h: DataHolder, m: MemberName): DataRevision;
-    getEditableRevision(h: DataHolder, m: MemberName, value: any, token?: any): DataRevision;
-    static takeSnapshot<T>(obj: T): T;
-    static dispose(obj: any): void;
-    static doDispose(ctx: Snapshot, h: DataHolder): DataRevision;
-    private isNewRevisionRequired;
-    acquire(outer: Snapshot): void;
-    bumpBy(timestamp: number): void;
-    rebase(): DataRevision[] | undefined;
-    private merge;
-    applyOrDiscard(error?: any): Array<Subscriber>;
-    static sealObjectRevision(h: DataHolder, r: DataRevision): void;
-    static sealSubscription(subscription: Subscription | symbol, m: MemberName, typeName: string): void;
-    static freezeObjectRevision(r: DataRevision): DataRevision;
-    triggerGarbageCollection(): void;
-    private unlinkHistory;
-    static _init(): void;
-}
-export declare class Dump {
-    static valueHint: (value: any, m?: PropertyKey | undefined) => string;
-    static obj(h: DataHolder | undefined, m?: MemberName | undefined, stamp?: number, snapshotId?: number, originSnapshotId?: number, value?: any): string;
-    static rev2(h: DataHolder, s: AbstractSnapshot, m?: MemberName, o?: Subscription): string;
-    static rev(r: DataRevision, m?: MemberName): string;
-    static conflicts(conflicts: DataRevision[]): string;
-    static conflictingMemberHint(m: MemberName, ours: DataRevision, theirs: DataRevision): string;
-}
-export declare const ROOT_REV: DataRevision;
-export declare const DefaultSnapshotOptions: SnapshotOptions;

package/build/dist/source/impl/Snapshot.js

@@ -1,353 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultSnapshotOptions = exports.ROOT_REV = exports.Dump = exports.Snapshot = exports.UNDEFINED_TIMESTAMP = exports.MAX_TIMESTAMP = void 0;
-const Utils_1 = require("../util/Utils");
-const Dbg_1 = require("../util/Dbg");
-const Sealant_1 = require("../util/Sealant");
-const SealedArray_1 = require("../util/SealedArray");
-const SealedMap_1 = require("../util/SealedMap");
-const SealedSet_1 = require("../util/SealedSet");
-const Data_1 = require("./Data");
-exports.MAX_TIMESTAMP = Number.MAX_SAFE_INTEGER;
-exports.UNDEFINED_TIMESTAMP = exports.MAX_TIMESTAMP - 1;
-Object.defineProperty(Data_1.DataHolder.prototype, '#this', {
-    configurable: false, enumerable: false,
-    get() {
-        const result = {};
-        const data = Snapshot.current().getCurrentRevision(this, '#this').data;
-        for (const m in data) {
-            const v = data[m];
-            if (v instanceof Data_1.Subscription)
-                result[m] = v.content;
-            else if (v === Data_1.Meta.Nonreactive)
-                result[m] = this.data[m];
-            else
-                result[m] = v;
-        }
-        return result;
-    },
-});
-const EMPTY_ARRAY = Object.freeze([]);
-const EMPTY_MAP = Utils_1.Utils.freezeMap(new Map());
-class Snapshot {
-    constructor(options) {
-        this.id = ++Snapshot.idGen;
-        this.options = options !== null && options !== void 0 ? options : exports.DefaultSnapshotOptions;
-        this.stamp = exports.UNDEFINED_TIMESTAMP;
-        this.bumper = 100;
-        this.changeset = new Map();
-        this.reactions = [];
-        this.sealed = false;
-    }
-    get hint() { var _a; return (_a = this.options.hint) !== null && _a !== void 0 ? _a : 'noname'; }
-    get timestamp() { return this.stamp; }
-    seekRevision(h, m) {
-        let r = h.editing;
-        if (r && r.snapshot !== this) {
-            r = this.changeset.get(h);
-            if (r)
-                h.editing = r;
-        }
-        if (!r) {
-            r = h.head;
-            while (r !== exports.ROOT_REV && r.snapshot.timestamp > this.timestamp)
-                r = r.former.revision;
-        }
-        return r;
-    }
-    getCurrentRevision(h, m) {
-        const r = this.seekRevision(h, m);
-        if (r === exports.ROOT_REV)
-            throw (0, Dbg_1.misuse)(`object ${Dump.obj(h)} doesn't exist in snapshot v${this.stamp} (${this.hint})`);
-        return r;
-    }
-    getEditableRevision(h, m, value, token) {
-        let r = this.seekRevision(h, m);
-        const existing = r.data[m];
-        if (existing !== Data_1.Meta.Nonreactive) {
-            if (this.isNewRevisionRequired(h, r, m, existing, value, token)) {
-                const data = Object.assign({}, m === Data_1.Meta.Holder ? value : r.data);
-                Reflect.set(data, Data_1.Meta.Holder, h);
-                r = new Data_1.DataRevision(this, r, data);
-                this.changeset.set(h, r);
-                h.editing = r;
-                h.editors++;
-                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
-                    Dbg_1.Log.write('║', '  ⎘', `${Dump.obj(h)} is cloned`);
-            }
-        }
-        else
-            r = exports.ROOT_REV;
-        return r;
-    }
-    static takeSnapshot(obj) {
-        return obj[Data_1.Meta.Holder]['#this'];
-    }
-    static dispose(obj) {
-        const ctx = Snapshot.edit();
-        const h = Data_1.Meta.get(obj, Data_1.Meta.Holder);
-        if (h !== undefined)
-            Snapshot.doDispose(ctx, h);
-    }
-    static doDispose(ctx, h) {
-        const r = ctx.getEditableRevision(h, Data_1.Meta.Disposed, Data_1.Meta.Disposed);
-        if (r !== exports.ROOT_REV) {
-            r.data[Data_1.Meta.Disposed] = Data_1.Meta.Disposed;
-            Snapshot.markEdited(Data_1.Meta.Disposed, Data_1.Meta.Disposed, true, r, Data_1.Meta.Disposed, h);
-        }
-        return r;
-    }
-    isNewRevisionRequired(h, r, m, existing, value, token) {
-        if (this.sealed && r.snapshot !== exports.ROOT_REV.snapshot)
-            throw (0, Dbg_1.misuse)(`reactive property ${Dump.obj(h, m)} can only be modified inside transaction`);
-        if (m !== Data_1.Meta.Holder && value !== Data_1.Meta.Holder) {
-            if (r.snapshot !== this || r.former.revision !== exports.ROOT_REV) {
-                if (this.options.token !== undefined && token !== this.options.token)
-                    throw (0, Dbg_1.misuse)(`${this.hint} should not have side effects (trying to change ${Dump.rev(r, m)})`);
-            }
-            if (r === exports.ROOT_REV)
-                throw (0, Dbg_1.misuse)(`member ${Dump.rev(r, m)} doesn't exist in snapshot v${this.stamp} (${this.hint})`);
-        }
-        return r.snapshot !== this && !this.sealed;
-    }
-    acquire(outer) {
-        if (!this.sealed && this.stamp === exports.UNDEFINED_TIMESTAMP) {
-            const ahead = this.options.token === undefined || outer.stamp === exports.UNDEFINED_TIMESTAMP;
-            this.stamp = ahead ? Snapshot.stampGen : outer.stamp;
-            Snapshot.pending.push(this);
-            if (Snapshot.oldest === undefined)
-                Snapshot.oldest = this;
-            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
-                Dbg_1.Log.write('╔══', `v${this.stamp}`, `${this.hint}`);
-        }
-    }
-    bumpBy(timestamp) {
-        if (timestamp > this.bumper)
-            this.bumper = timestamp;
-    }
-    rebase() {
-        let conflicts = undefined;
-        if (this.changeset.size > 0) {
-            this.changeset.forEach((r, h) => {
-                if (r.former.revision !== h.head) {
-                    const merged = this.merge(h, r);
-                    if (r.conflicts.size > 0) {
-                        if (!conflicts)
-                            conflicts = [];
-                        conflicts.push(r);
-                    }
-                    if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
-                        Dbg_1.Log.write('╠╝', '', `${Dump.rev2(h, r.snapshot)} is merged with ${Dump.rev2(h, h.head.snapshot)} among ${merged} properties with ${r.conflicts.size} conflicts.`);
-                }
-            });
-            if (this.options.token === undefined) {
-                if (this.bumper > 100) {
-                    this.bumper = this.stamp;
-                    this.stamp = ++Snapshot.stampGen;
-                }
-                else
-                    this.stamp = this.bumper + 1;
-            }
-            else {
-                this.stamp = this.bumper;
-            }
-        }
-        return conflicts;
-    }
-    merge(h, ours) {
-        let counter = 0;
-        const head = h.head;
-        const headDisposed = head.changes.has(Data_1.Meta.Disposed);
-        const merged = Object.assign({}, head.data);
-        ours.changes.forEach((o, m) => {
-            counter++;
-            merged[m] = ours.data[m];
-            if (headDisposed || m === Data_1.Meta.Disposed) {
-                if (headDisposed !== (m === Data_1.Meta.Disposed)) {
-                    if (headDisposed || this.options.standalone !== 'disposal') {
-                        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
-                            Dbg_1.Log.write('║╠', '', `${Dump.rev2(h, ours.snapshot, m)} <> ${Dump.rev2(h, head.snapshot, m)}`, 0, ' *** CONFLICT ***');
-                        ours.conflicts.set(m, head);
-                    }
-                }
-            }
-            else {
-                const conflict = Snapshot.isConflicting(head.data[m], ours.former.revision.data[m]);
-                if (conflict)
-                    ours.conflicts.set(m, head);
-                if (Dbg_1.Log.isOn && Dbg_1.Log.opt.change)
-                    Dbg_1.Log.write('║╠', '', `${Dump.rev2(h, ours.snapshot, m)} ${conflict ? '<>' : '=='} ${Dump.rev2(h, head.snapshot, m)}`, 0, conflict ? ' *** CONFLICT ***' : undefined);
-            }
-        });
-        Utils_1.Utils.copyAllMembers(merged, ours.data);
-        ours.former.revision = head;
-        return counter;
-    }
-    applyOrDiscard(error) {
-        this.sealed = true;
-        this.changeset.forEach((r, h) => {
-            Snapshot.sealObjectRevision(h, r);
-            h.editors--;
-            if (h.editors === 0)
-                h.editing = undefined;
-            if (!error) {
-                h.head = r;
-                if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                    Snapshot.totalRevisionCount++;
-                    if (r.former.revision === exports.ROOT_REV)
-                        Snapshot.totalHolderCount++;
-                }
-            }
-        });
-        if (Dbg_1.Log.isOn) {
-            if (Dbg_1.Log.opt.change && !error) {
-                this.changeset.forEach((r, h) => {
-                    const members = [];
-                    r.changes.forEach((o, m) => members.push(m.toString()));
-                    const s = members.join(', ');
-                    Dbg_1.Log.write('║', '√', `${Dump.rev2(h, r.snapshot)} (${s}) is ${r.former.revision === exports.ROOT_REV ? 'constructed' : `applied on top of ${Dump.rev2(h, r.former.revision.snapshot)}`}`);
-                });
-            }
-            if (Dbg_1.Log.opt.transaction)
-                Dbg_1.Log.write(this.stamp < exports.UNDEFINED_TIMESTAMP ? '╚══' : '═══', `v${this.stamp}`, `${this.hint} - ${error ? 'CANCEL' : 'APPLY'}(${this.changeset.size})${error ? ` - ${error}` : ''}`);
-        }
-        if (!error)
-            Snapshot.propagateAllChangesThroughSubscriptions(this);
-        return this.reactions;
-    }
-    static sealObjectRevision(h, r) {
-        if (!r.changes.has(Data_1.Meta.Disposed))
-            r.changes.forEach((o, m) => Snapshot.sealSubscription(r.data[m], m, h.proxy.constructor.name));
-        else
-            for (const m in r.former.revision.data)
-                r.data[m] = Data_1.Meta.Disposed;
-        if (Dbg_1.Log.isOn)
-            Snapshot.freezeObjectRevision(r);
-    }
-    static sealSubscription(subscription, m, typeName) {
-        if (subscription instanceof Data_1.Subscription) {
-            const value = subscription.content;
-            if (value !== undefined && value !== null) {
-                const sealedType = Object.getPrototypeOf(value)[Sealant_1.Sealant.SealedType];
-                if (sealedType)
-                    subscription.content = Sealant_1.Sealant.seal(value, sealedType, typeName, m);
-            }
-        }
-    }
-    static freezeObjectRevision(r) {
-        Object.freeze(r.data);
-        Utils_1.Utils.freezeSet(r.changes);
-        Utils_1.Utils.freezeMap(r.conflicts);
-        return r;
-    }
-    triggerGarbageCollection() {
-        if (this.stamp !== 0) {
-            if (this === Snapshot.oldest) {
-                const p = Snapshot.pending;
-                p.sort((a, b) => a.stamp - b.stamp);
-                let i = 0;
-                while (i < p.length && p[i].sealed) {
-                    p[i].unlinkHistory();
-                    i++;
-                }
-                Snapshot.pending = p.slice(i);
-                Snapshot.oldest = Snapshot.pending[0];
-                const now = Date.now();
-                if (now - Snapshot.lastGarbageCollectionSummaryTimestamp > Snapshot.garbageCollectionSummaryInterval) {
-                    Dbg_1.Log.write('', '[G]', `Total object/revision count: ${Snapshot.totalHolderCount}/${Snapshot.totalRevisionCount}`);
-                    Snapshot.lastGarbageCollectionSummaryTimestamp = now;
-                }
-            }
-        }
-    }
-    unlinkHistory() {
-        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc)
-            Dbg_1.Log.write('', '[G]', `Dismiss history below v${this.stamp}t${this.id} (${this.hint})`);
-        this.changeset.forEach((r, h) => {
-            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.gc && r.former.revision !== exports.ROOT_REV)
-                Dbg_1.Log.write(' ', '  ', `${Dump.rev2(h, r.former.revision.snapshot)} is ready for GC because overwritten by ${Dump.rev2(h, r.snapshot)}`);
-            if (Snapshot.garbageCollectionSummaryInterval < Number.MAX_SAFE_INTEGER) {
-                if (r.former.revision !== exports.ROOT_REV)
-                    Snapshot.totalRevisionCount--;
-                if (r.changes.has(Data_1.Meta.Disposed))
-                    Snapshot.totalHolderCount--;
-            }
-            r.former.revision = exports.ROOT_REV;
-        });
-        this.changeset = EMPTY_MAP;
-        this.reactions = EMPTY_ARRAY;
-        if (Dbg_1.Log.isOn)
-            Object.freeze(this);
-    }
-    static _init() {
-        const boot = exports.ROOT_REV.snapshot;
-        boot.acquire(boot);
-        boot.applyOrDiscard();
-        boot.triggerGarbageCollection();
-        Snapshot.freezeObjectRevision(exports.ROOT_REV);
-        Snapshot.idGen = 100;
-        Snapshot.stampGen = 101;
-        Snapshot.oldest = undefined;
-        SealedArray_1.SealedArray.prototype;
-        SealedMap_1.SealedMap.prototype;
-        SealedSet_1.SealedSet.prototype;
-    }
-}
-exports.Snapshot = Snapshot;
-Snapshot.idGen = -1;
-Snapshot.stampGen = 1;
-Snapshot.pending = [];
-Snapshot.oldest = undefined;
-Snapshot.garbageCollectionSummaryInterval = Number.MAX_SAFE_INTEGER;
-Snapshot.lastGarbageCollectionSummaryTimestamp = Date.now();
-Snapshot.totalHolderCount = 0;
-Snapshot.totalRevisionCount = 0;
-Snapshot.current = Utils_1.UNDEF;
-Snapshot.edit = Utils_1.UNDEF;
-Snapshot.markUsed = Utils_1.UNDEF;
-Snapshot.markEdited = Utils_1.UNDEF;
-Snapshot.isConflicting = Utils_1.UNDEF;
-Snapshot.propagateAllChangesThroughSubscriptions = (snapshot) => { };
-Snapshot.revokeAllSubscriptions = (snapshot) => { };
-Snapshot.enqueueReactionsToRun = (reactions) => { };
-class Dump {
-    static obj(h, m, stamp, snapshotId, originSnapshotId, value) {
-        const member = m !== undefined ? `.${m.toString()}` : '';
-        return h === undefined
-            ? `boot${member}`
-            : stamp === undefined
-                ? `${h.hint}${member}${value !== undefined ? `[=${Dump.valueHint(value)}]` : ''} #${h.id}`
-                : `${h.hint}${member}${value !== undefined ? `[=${Dump.valueHint(value)}]` : ''} #${h.id}t${snapshotId}v${stamp}${originSnapshotId !== undefined && originSnapshotId !== 0 ? `t${originSnapshotId}` : ''}`;
-    }
-    static rev2(h, s, m, o) {
-        var _a;
-        return Dump.obj(h, m, s.timestamp, s.id, o === null || o === void 0 ? void 0 : o.originSnapshotId, (_a = o === null || o === void 0 ? void 0 : o.content) !== null && _a !== void 0 ? _a : Data_1.Meta.Undefined);
-    }
-    static rev(r, m) {
-        const h = Data_1.Meta.get(r.data, Data_1.Meta.Holder);
-        const value = m !== undefined ? r.data[m] : undefined;
-        return Dump.obj(h, m, r.snapshot.timestamp, r.snapshot.id, value === null || value === void 0 ? void 0 : value.originSnapshotId);
-    }
-    static conflicts(conflicts) {
-        return conflicts.map(ours => {
-            const items = [];
-            ours.conflicts.forEach((theirs, m) => {
-                items.push(Dump.conflictingMemberHint(m, ours, theirs));
-            });
-            return items.join(', ');
-        }).join(', ');
-    }
-    static conflictingMemberHint(m, ours, theirs) {
-        return `${theirs.snapshot.hint} (${Dump.rev(theirs, m)})`;
-    }
-}
-exports.Dump = Dump;
-Dump.valueHint = (value, m) => '???';
-exports.ROOT_REV = new Data_1.DataRevision(new Snapshot({ hint: '<root>' }), undefined, {});
-exports.DefaultSnapshotOptions = Object.freeze({
-    hint: 'noname',
-    standalone: false,
-    journal: undefined,
-    logging: undefined,
-    token: undefined,
-});