reactronic 0.22.308 → 0.22.309

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

@@ -0,0 +1,30 @@
+import { F } from '../util/Utils';
+import { Worker } from '../Worker';
+import { SnapshotOptions } from '../Options';
+import { Changeset } from './Changeset';
+export declare abstract class Transaction implements Worker {
+    static get current(): Transaction;
+    abstract readonly id: number;
+    abstract readonly hint: string;
+    abstract readonly options: SnapshotOptions;
+    abstract readonly timestamp: number;
+    abstract readonly error: Error | undefined;
+    abstract readonly changeset: Changeset;
+    abstract readonly margin: number;
+    abstract run<T>(func: F<T>, ...args: any[]): T;
+    abstract inspect<T>(func: F<T>, ...args: any[]): T;
+    abstract apply(): void;
+    abstract seal(): this;
+    abstract wrap<T>(func: F<T>, secondary: boolean): F<T>;
+    abstract cancel(error: Error, retryAfterOrIgnore?: Worker | null): this;
+    abstract readonly isCanceled: boolean;
+    abstract readonly isFinished: boolean;
+    whenFinished(): Promise<void>;
+    static create(options: SnapshotOptions | null): Transaction;
+    static run<T>(options: SnapshotOptions | null, func: F<T>, ...args: any[]): T;
+    static standalone<T>(func: F<T>, ...args: any[]): T;
+    static off<T>(func: F<T>, ...args: any[]): T;
+    static isFrameOver(everyN?: number, timeLimit?: number): boolean;
+    static requestNextFrame(sleepTime?: number): Promise<void>;
+    static get isCanceled(): boolean;
+}

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

@@ -0,0 +1,313 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transaction = void 0;
+const Utils_1 = require("../util/Utils");
+const Dbg_1 = require("../util/Dbg");
+const Changeset_1 = require("./Changeset");
+class Transaction {
+    static get current() { return TransactionImpl.current; }
+    whenFinished() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    static create(options) { return new TransactionImpl(options); }
+    static run(options, func, ...args) { return TransactionImpl.run(options, func, ...args); }
+    static standalone(func, ...args) { return TransactionImpl.standalone(func, ...args); }
+    static off(func, ...args) { return TransactionImpl.off(func, ...args); }
+    static isFrameOver(everyN = 1, timeLimit = 10) { return TransactionImpl.isFrameOver(everyN, timeLimit); }
+    static requestNextFrame(sleepTime = 0) { return TransactionImpl.requestNextFrame(sleepTime); }
+    static get isCanceled() { return TransactionImpl.current.isCanceled; }
+}
+exports.Transaction = Transaction;
+class TransactionImpl extends Transaction {
+    constructor(options) {
+        super();
+        this.margin = TransactionImpl.curr !== undefined ? TransactionImpl.curr.margin + 1 : -1;
+        this.changeset = new Changeset_1.Changeset(options);
+        this.pending = 0;
+        this.sealed = false;
+        this.canceled = undefined;
+        this.after = undefined;
+        this.promise = undefined;
+        this.resolve = Utils_1.UNDEF;
+        this.reject = Utils_1.UNDEF;
+    }
+    static get current() { return TransactionImpl.curr; }
+    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();
+        return this.runImpl(undefined, func, ...args);
+    }
+    inspect(func, ...args) {
+        const restore = TransactionImpl.inspection;
+        try {
+            TransactionImpl.inspection = true;
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction)
+                Dbg_1.Log.write(' ', ' ', `T${this.id}[${this.hint}] is being inspected by T${TransactionImpl.curr.id}[${TransactionImpl.curr.hint}]`);
+            return this.runImpl(undefined, func, ...args);
+        }
+        finally {
+            TransactionImpl.inspection = restore;
+        }
+    }
+    apply() {
+        if (this.pending > 0)
+            throw (0, Dbg_1.misuse)('cannot apply transaction having active operations running');
+        if (this.canceled)
+            throw (0, Dbg_1.misuse)(`cannot apply transaction that is already canceled: ${this.canceled}`);
+        this.seal();
+    }
+    seal() {
+        if (!this.sealed)
+            this.run(TransactionImpl.seal, this, undefined, undefined);
+        return this;
+    }
+    wrap(func, error) {
+        this.guard();
+        const self = this;
+        const inspect = TransactionImpl.inspection;
+        if (!inspect)
+            self.run(TransactionImpl.wrapperEnter, self, error);
+        else
+            self.inspect(TransactionImpl.wrapperEnter, self, error);
+        const wrappedForTransaction = (...args) => {
+            if (!inspect)
+                return self.runImpl(undefined, TransactionImpl.wrapperLeave, self, error, func, ...args);
+            else
+                return self.inspect(TransactionImpl.wrapperLeave, self, error, func, ...args);
+        };
+        return wrappedForTransaction;
+    }
+    static wrapperEnter(t, error) {
+        if (!error)
+            t.pending++;
+    }
+    static wrapperLeave(t, error, func, ...args) {
+        t.pending--;
+        const result = func(...args);
+        return result;
+    }
+    cancel(error, restartAfter) {
+        this.runImpl(undefined, TransactionImpl.seal, this, error, restartAfter === null ? TransactionImpl.none : restartAfter);
+        return this;
+    }
+    get isCanceled() {
+        return this.canceled !== undefined;
+    }
+    get isFinished() {
+        return this.sealed && this.pending === 0;
+    }
+    whenFinished() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isFinished)
+                yield this.acquirePromise();
+        });
+    }
+    static run(options, func, ...args) {
+        const t = TransactionImpl.acquire(options);
+        const root = t !== TransactionImpl.curr;
+        t.guard();
+        let result = t.runImpl(options === null || options === void 0 ? void 0 : options.logging, func, ...args);
+        if (root) {
+            if (result instanceof Promise) {
+                result = TransactionImpl.off(() => {
+                    return t.wrapToRetry(t.wrapToWaitUntilFinish(result), func, ...args);
+                });
+            }
+            t.seal();
+        }
+        return result;
+    }
+    static standalone(func, ...args) {
+        return TransactionImpl.run({ standalone: true }, func, ...args);
+    }
+    static off(func, ...args) {
+        const outer = TransactionImpl.curr;
+        try {
+            TransactionImpl.curr = TransactionImpl.none;
+            return func(...args);
+        }
+        finally {
+            TransactionImpl.curr = outer;
+        }
+    }
+    static isFrameOver(everyN = 1, timeLimit = 10) {
+        TransactionImpl.frameOverCounter++;
+        let result = TransactionImpl.frameOverCounter % everyN === 0;
+        if (result) {
+            const ms = performance.now() - TransactionImpl.frameStartTime;
+            result = ms > timeLimit;
+        }
+        return result;
+    }
+    static requestNextFrame(sleepTime = 0) {
+        return (0, Utils_1.pause)(sleepTime);
+    }
+    static acquire(options) {
+        const curr = TransactionImpl.curr;
+        if ((options === null || options === void 0 ? void 0 : options.standalone) || curr.isFinished || curr.options.standalone === 'isolated')
+            return new TransactionImpl(options);
+        else
+            return TransactionImpl.curr;
+    }
+    guard() {
+        if (this.sealed && TransactionImpl.curr !== this)
+            throw (0, Dbg_1.misuse)('cannot run transaction that is already sealed');
+    }
+    wrapToRetry(p, func, ...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const result = yield p;
+                if (this.canceled)
+                    throw this.canceled;
+                return result;
+            }
+            catch (error) {
+                if (this.after !== TransactionImpl.none) {
+                    if (this.after) {
+                        yield this.after.whenFinished();
+                        const options = {
+                            hint: `${this.hint} - restart after T${this.after.id}`,
+                            standalone: this.options.standalone === 'isolated' ? 'isolated' : true,
+                            logging: this.changeset.options.logging,
+                            token: this.changeset.options.token,
+                        };
+                        return TransactionImpl.run(options, func, ...args);
+                    }
+                    else
+                        throw error;
+                }
+                else
+                    return undefined;
+            }
+        });
+    }
+    wrapToWaitUntilFinish(p) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield p;
+            yield this.whenFinished();
+            return result;
+        });
+    }
+    runImpl(logging, func, ...args) {
+        let result;
+        const outer = TransactionImpl.curr;
+        try {
+            if (outer === TransactionImpl.none) {
+                TransactionImpl.frameStartTime = performance.now();
+                TransactionImpl.frameOverCounter = 0;
+            }
+            TransactionImpl.curr = this;
+            this.pending++;
+            this.changeset.acquire(outer.changeset);
+            result = func(...args);
+            if (this.sealed && this.pending === 1) {
+                if (!this.canceled)
+                    this.checkForConflicts();
+                else if (!this.after)
+                    throw this.canceled;
+            }
+        }
+        catch (e) {
+            if (!TransactionImpl.inspection)
+                this.cancel(e);
+            throw e;
+        }
+        finally {
+            this.pending--;
+            if (this.sealed && this.pending === 0) {
+                const reactions = this.applyOrDiscard();
+                TransactionImpl.curr = outer;
+                TransactionImpl.off(Changeset_1.Changeset.enqueueReactionsToRun, reactions);
+            }
+            else
+                TransactionImpl.curr = outer;
+        }
+        return result;
+    }
+    static seal(t, error, after) {
+        if (!t.canceled && error) {
+            t.canceled = error;
+            t.after = after;
+            if (Dbg_1.Log.isOn && Dbg_1.Log.opt.transaction) {
+                Dbg_1.Log.write('║', ' [!]', `${error.message}`, undefined, ' *** CANCEL ***');
+                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}]` : ''}`);
+            }
+            Changeset_1.Changeset.revokeAllSubscriptions(t.changeset);
+        }
+        t.sealed = true;
+    }
+    checkForConflicts() {
+        const conflicts = this.changeset.rebase();
+        if (conflicts)
+            this.tryResolveConflicts(conflicts);
+    }
+    tryResolveConflicts(conflicts) {
+        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.changeset.applyOrDiscard(this.canceled);
+            this.changeset.triggerGarbageCollection();
+            if (this.promise) {
+                if (this.canceled && !this.after)
+                    this.reject(this.canceled);
+                else
+                    this.resolve();
+            }
+            if (Dbg_1.Log.isOn)
+                Object.freeze(this);
+        }
+        catch (e) {
+            (0, Dbg_1.fatal)(e);
+            throw e;
+        }
+        return reactions;
+    }
+    acquirePromise() {
+        if (!this.promise) {
+            this.promise = new Promise((resolve, reject) => {
+                this.resolve = resolve;
+                this.reject = reject;
+            });
+        }
+        return this.promise;
+    }
+    static getCurrentChangeset() {
+        return TransactionImpl.curr.changeset;
+    }
+    static getEditableChangeset() {
+        if (TransactionImpl.inspection)
+            throw (0, Dbg_1.misuse)('cannot make changes during transaction inspection');
+        return TransactionImpl.curr.changeset;
+    }
+    static _init() {
+        Changeset_1.Changeset.current = TransactionImpl.getCurrentChangeset;
+        Changeset_1.Changeset.edit = TransactionImpl.getEditableChangeset;
+        TransactionImpl.none.sealed = true;
+        TransactionImpl.none.changeset.applyOrDiscard();
+        Changeset_1.Changeset._init();
+    }
+}
+TransactionImpl.none = new TransactionImpl({ hint: 'Transaction.off' });
+TransactionImpl.curr = TransactionImpl.none;
+TransactionImpl.inspection = false;
+TransactionImpl.frameStartTime = 0;
+TransactionImpl.frameOverCounter = 0;
+TransactionImpl._init();

package/build/dist/source/util/Dbg.d.ts

@@ -0,0 +1,15 @@
+import { LoggingOptions } from '../Logging';
+export declare function error(message: string, dump: Error | undefined): Error;
+export declare function misuse(message: string, dump?: any): Error;
+export declare function fatal(error: Error): Error;
+export declare class Log {
+    static DefaultLevel: LoggingOptions;
+    static isOn: boolean;
+    static global: LoggingOptions;
+    static get opt(): LoggingOptions;
+    static getMergedLoggingOptions: (local: Partial<LoggingOptions> | undefined) => LoggingOptions;
+    static setMode(isOn: boolean, options?: LoggingOptions): void;
+    static write(bar: string, tran: string, message: string, ms?: number, highlight?: string | undefined, dump?: any): void;
+    static writeAs(options: Partial<LoggingOptions> | undefined, bar: string, tran: string, message: string, ms?: number, highlight?: string | undefined, dump?: any): void;
+    static merge(t: Partial<LoggingOptions> | undefined, color: number | undefined, prefix: string | undefined, existing: LoggingOptions): LoggingOptions;
+}

package/build/dist/source/util/Dbg.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = exports.fatal = exports.misuse = exports.error = void 0;
+function error(message, dump) {
+    if (Log.isOn && Log.opt.error)
+        Log.write('█', ' ███', message, undefined, ' *** ERROR ***', dump);
+    return new Error(message);
+}
+exports.error = error;
+function misuse(message, dump) {
+    const error = new Error(message);
+    Log.write(' ', ' ███', message, undefined, ' *** ERROR / MISUSE ***', dump !== null && dump !== void 0 ? dump : error);
+    return error;
+}
+exports.misuse = misuse;
+function fatal(error) {
+    Log.write(' ', ' ███', error.message, undefined, ' *** FATAL ***', error);
+    return error;
+}
+exports.fatal = fatal;
+class Log {
+    static get opt() { return this.getMergedLoggingOptions(undefined); }
+    static setMode(isOn, options) {
+        Log.global = options || Log.DefaultLevel;
+        if (isOn) {
+            const t = Log.global;
+            const o = Object.keys(Log.global).filter(x => t[x] === true).join(', ');
+            Log.write('', '', `Reactronic logging is turned on: ${o}`);
+            Log.write('', '', 'Member-level logging can be configured with @options({ logging: ... }) decorator');
+        }
+        else if (Log.isOn)
+            Log.write('', '', 'Reactronic logging is turned off');
+        Log.isOn = isOn;
+    }
+    static write(bar, tran, message, ms = 0, highlight = undefined, dump) {
+        Log.writeAs(undefined, bar, tran, message, ms, highlight, dump);
+    }
+    static writeAs(options, bar, tran, message, ms = 0, highlight = undefined, dump) {
+        const t = Log.getMergedLoggingOptions(options);
+        const margin1 = '  '.repeat(t.margin1 >= 0 ? t.margin1 : 0);
+        const margin2 = '  '.repeat(t.margin2);
+        const enabled = (options && options.enabled !== undefined) ? options.enabled : t.enabled;
+        if (enabled) {
+            console.log('\x1b[37m%s\x1b[0m \x1b[' + t.color + 'm%s %s%s\x1b[0m \x1b[' + t.color + 'm%s%s\x1b[0m \x1b[' + t.color + 'm%s\x1b[0m%s', '', t.prefix, t.transaction ? margin1 : '', t.transaction ? bar : bar.replace(/./g, ' '), margin2, tran, message, (highlight !== undefined ? `${highlight}` : '') + (ms > 2 ? `    [ ${ms}ms ]` : ''));
+            if (dump)
+                console.log(dump);
+        }
+    }
+    static merge(t, color, prefix, existing) {
+        const result = !t ? Object.assign({}, existing) : {
+            enabled: t.enabled !== undefined ? t.enabled : existing.enabled,
+            transaction: t.transaction !== undefined ? t.transaction : existing.transaction,
+            operation: t.operation !== undefined ? t.operation : existing.operation,
+            step: t.step !== undefined ? t.step : existing.step,
+            monitor: t.monitor !== undefined ? t.monitor : existing.monitor,
+            read: t.read !== undefined ? t.read : existing.read,
+            write: t.write !== undefined ? t.write : existing.write,
+            change: t.change !== undefined ? t.change : existing.change,
+            obsolete: t.obsolete !== undefined ? t.obsolete : existing.obsolete,
+            error: t.error !== undefined ? t.error : existing.error,
+            warning: t.warning !== undefined ? t.warning : existing.warning,
+            gc: t.gc !== undefined ? t.gc : existing.gc,
+            color: t.color !== undefined ? t.color : existing.color,
+            prefix: t.prefix !== undefined ? t.prefix : existing.prefix,
+            margin1: t.margin1 !== undefined ? t.margin1 : existing.margin1,
+            margin2: t.margin2 !== undefined ? t.margin2 : existing.margin2,
+        };
+        if (color !== undefined)
+            result.color = color;
+        if (prefix !== undefined)
+            result.prefix = prefix;
+        return result;
+    }
+}
+exports.Log = Log;
+Log.DefaultLevel = {
+    enabled: true,
+    error: false,
+    warning: false,
+    transaction: false,
+    operation: false,
+    step: false,
+    monitor: false,
+    read: false,
+    write: false,
+    change: false,
+    obsolete: false,
+    gc: false,
+    color: 37,
+    prefix: '',
+    margin1: 0,
+    margin2: 0,
+};
+Log.isOn = false;
+Log.global = Log.DefaultLevel;
+Log.getMergedLoggingOptions = (local) => Log.global;

package/build/dist/source/util/Sealant.d.ts

@@ -0,0 +1,14 @@
+export interface Sealable<T> {
+    toMutable(): T;
+    [Sealant.SealedType]: object;
+}
+export interface Sealed<T> {
+    [Sealant.CreateCopy]?: () => T;
+}
+export declare abstract class Sealant {
+    static readonly SealedType: unique symbol;
+    static readonly CreateCopy: unique symbol;
+    static seal<T extends Sealable<T>>(collection: T, sealedType: object, typeName: string, member: any): T;
+    static toMutable<T extends Sealable<T>>(collection: T): T;
+    static error(collection: Sealed<any>): Error;
+}

package/build/dist/source/util/Sealant.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sealant = void 0;
+const Dbg_1 = require("./Dbg");
+class Sealant {
+    static seal(collection, sealedType, typeName, member) {
+        let result = collection;
+        const createCopy = result[Sealant.CreateCopy];
+        if (createCopy)
+            result = createCopy.call(result);
+        if (Dbg_1.Log.isOn && Dbg_1.Log.opt.write)
+            Dbg_1.Log.write('║', ' ', `${typeName}.${member.toString()} - collection is sealed`);
+        Object.setPrototypeOf(result, sealedType);
+        Object.freeze(result);
+        return result;
+    }
+    static toMutable(collection) {
+        const a = collection;
+        const createCopy = a[Sealant.CreateCopy];
+        if (createCopy)
+            collection = createCopy.call(collection);
+        return collection;
+    }
+    static error(collection) {
+        return (0, Dbg_1.misuse)('use toMutable to create mutable copy of sealed collection');
+    }
+}
+exports.Sealant = Sealant;
+Sealant.SealedType = Symbol('rxSealedType');
+Sealant.CreateCopy = Symbol('rxCreateCopy');

package/build/dist/source/util/SealedArray.d.ts

@@ -0,0 +1,16 @@
+import { Sealant, Sealed } from './Sealant';
+declare global {
+    interface Array<T> {
+        toMutable(): Array<T>;
+        [Sealant.SealedType]: object;
+    }
+}
+export declare abstract class SealedArray<T> extends Array<T> implements Sealed<Array<T>> {
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    sort(compareFn?: (a: T, b: T) => number): this;
+    splice(start: number, deleteCount?: number): T[];
+    unshift(...items: T[]): number;
+    [Sealant.CreateCopy](): Array<T>;
+    slice(start?: number, end?: number): T[];
+}

package/build/dist/source/util/SealedArray.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SealedArray = void 0;
+const Sealant_1 = require("./Sealant");
+class SealedArray extends Array {
+    pop() { throw Sealant_1.Sealant.error(this); }
+    push(...items) { throw Sealant_1.Sealant.error(this); }
+    sort(compareFn) { throw Sealant_1.Sealant.error(this); }
+    splice(start, deleteCount, ...items) { throw Sealant_1.Sealant.error(this); }
+    unshift(...items) { throw Sealant_1.Sealant.error(this); }
+    [Sealant_1.Sealant.CreateCopy]() { return this.slice(); }
+    slice(start, end) {
+        const result = super.slice(start, end);
+        Object.setPrototypeOf(result, Array.prototype);
+        return result;
+    }
+}
+exports.SealedArray = SealedArray;
+Object.defineProperty(Array.prototype, 'toMutable', {
+    configurable: false, enumerable: false,
+    value() {
+        return Sealant_1.Sealant.toMutable(this);
+    },
+});
+Object.defineProperty(Array.prototype, Sealant_1.Sealant.SealedType, {
+    value: SealedArray.prototype,
+    configurable: false, enumerable: false, writable: false,
+});

package/build/dist/source/util/SealedMap.d.ts

@@ -0,0 +1,13 @@
+import { Sealant, Sealed } from './Sealant';
+declare global {
+    interface Map<K, V> {
+        toMutable(): Map<K, V>;
+        [Sealant.SealedType]: object;
+    }
+}
+export declare abstract class SealedMap<K, V> extends Map<K, V> implements Sealed<Map<K, V>> {
+    clear(): void;
+    delete(key: K): boolean;
+    set(key: K, value: V): this;
+    [Sealant.CreateCopy](): Map<K, V>;
+}

package/build/dist/source/util/SealedMap.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SealedMap = void 0;
+const Sealant_1 = require("./Sealant");
+class SealedMap extends Map {
+    clear() { throw Sealant_1.Sealant.error(this); }
+    delete(key) { throw Sealant_1.Sealant.error(this); }
+    set(key, value) { throw Sealant_1.Sealant.error(this); }
+    [Sealant_1.Sealant.CreateCopy]() { return new Map(this.entries()); }
+}
+exports.SealedMap = SealedMap;
+Object.defineProperty(Map.prototype, 'toMutable', {
+    configurable: false, enumerable: false,
+    value() {
+        return Sealant_1.Sealant.toMutable(this);
+    },
+});
+Object.defineProperty(Map.prototype, Sealant_1.Sealant.SealedType, {
+    value: SealedMap.prototype,
+    configurable: false, enumerable: false, writable: false,
+});

package/build/dist/source/util/SealedSet.d.ts

@@ -0,0 +1,13 @@
+import { Sealant, Sealed } from './Sealant';
+declare global {
+    interface Set<T> {
+        toMutable(): Set<T>;
+        [Sealant.SealedType]: object;
+    }
+}
+export declare abstract class SealedSet<T> extends Set<T> implements Sealed<Set<T>> {
+    add(value: T): this;
+    clear(): void;
+    delete(value: T): boolean;
+    [Sealant.CreateCopy](): Set<T>;
+}

package/build/dist/source/util/SealedSet.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SealedSet = void 0;
+const Sealant_1 = require("./Sealant");
+class SealedSet extends Set {
+    add(value) { throw Sealant_1.Sealant.error(this); }
+    clear() { throw Sealant_1.Sealant.error(this); }
+    delete(value) { throw Sealant_1.Sealant.error(this); }
+    [Sealant_1.Sealant.CreateCopy]() { return new Set(this.values()); }
+}
+exports.SealedSet = SealedSet;
+Object.defineProperty(Set.prototype, 'toMutable', {
+    configurable: false, enumerable: false,
+    value() {
+        return Sealant_1.Sealant.toMutable(this);
+    },
+});
+Object.defineProperty(Set.prototype, Sealant_1.Sealant.SealedType, {
+    value: SealedSet.prototype,
+    configurable: false, enumerable: false, writable: false,
+});

package/build/dist/source/util/Utils.d.ts

@@ -0,0 +1,9 @@
+export declare type F<T> = (...args: any[]) => T;
+export declare class Utils {
+    static freezeSet<T>(obj?: Set<T>): Set<T> | undefined;
+    static freezeMap<K, V>(obj?: Map<K, V>): Map<K, V> | undefined;
+    static copyAllMembers(source: any, target: any): any;
+}
+export declare function UNDEF(...args: any[]): never;
+export declare function all(promises: Array<Promise<any>>): Promise<any[]>;
+export declare function pause<T>(timeout: number): Promise<T>;