wenay-common2 1.0.46 → 1.0.49

package/lib/Common/async/waitRun.js

@@ -1,51 +1,59 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.enhancedWaitRun = enhancedWaitRun;
+exports.createTaskQueue = exports.enhancedWaitRun = void 0;
+exports.createThrottle = createThrottle;
 exports.createAsyncQueue = createAsyncQueue;
 exports.enhancedQueueRun = enhancedQueueRun;
 exports.waitRun = waitRun;
 exports.queueRun = queueRun;
-exports.createTaskQueue = createTaskQueue;
+exports.createReadyGate = createReadyGate;
 const common_1 = require("../core/common");
-function enhancedWaitRun() {
+function createThrottle() {
     let last = 0, busy = false, pending;
     let chain = Promise.resolve();
+    const throttle = (ms, func) => {
+        if (busy || last + ms >= Date.now())
+            return;
+        busy = true;
+        chain = chain.catch(() => { }).then(async () => {
+            try {
+                return await func();
+            }
+            finally {
+                busy = false;
+                last = Date.now();
+            }
+        }).catch(() => { });
+    };
+    const debounce = (ms, func) => {
+        if (!func)
+            throw new Error("debounceAsync: func is undefined");
+        pending = func;
+        if (busy)
+            return chain;
+        busy = true;
+        return chain = chain.finally(async () => {
+            try {
+                await (0, common_1.sleepAsync)(ms);
+                await pending?.();
+            }
+            finally {
+                busy = false;
+                chain = Promise.resolve();
+            }
+        });
+    };
     return {
-        throttleAsync: (ms, func) => {
-            if (busy || last + ms >= Date.now())
-                return;
-            busy = true;
-            chain = chain.then(async () => {
-                try {
-                    return await func();
-                }
-                finally {
-                    busy = false;
-                    last = Date.now();
-                }
-            });
-        },
-        debounceAsync: (ms, func) => {
-            if (!func)
-                throw new Error("debounceAsync: func is undefined");
-            pending = func;
-            if (busy)
-                return chain;
-            busy = true;
-            return chain = chain.finally(async () => {
-                try {
-                    await (0, common_1.sleepAsync)(ms);
-                    await pending?.();
-                }
-                finally {
-                    busy = false;
-                    chain = Promise.resolve();
-                }
-            });
-        },
+        throttle,
+        debounce,
+        throttleAsync: throttle,
+        debounceAsync: debounce,
     };
 }
+exports.enhancedWaitRun = createThrottle;
 function createAsyncQueue(concurrency = 1) {
+    if (concurrency < 1)
+        throw new Error("createAsyncQueue: concurrency must be >= 1");
     const queue = [];
     let active = 0, resolveIdle = null, idle = null;
     const drain = () => {
@@ -67,19 +75,25 @@ function createAsyncQueue(concurrency = 1) {
     } }); drain(); });
     const onIdle = () => idle ??= new Promise(r => (active === 0 && !queue.length) ? r() : (resolveIdle = r));
     const getQueueSize = () => queue.length;
-    return { enqueue, onIdle, getQueueSize };
+    return {
+        add: enqueue,
+        onIdle,
+        get size() { return queue.length; },
+        enqueue,
+        getQueueSize,
+    };
 }
 function enhancedQueueRun(maxParallelTasks = 5) {
     const q = createAsyncQueue(maxParallelTasks);
     return {
         get queueSize() { return q.getQueueSize(); },
-        enqueue: (task) => { q.enqueue(task); },
+        enqueue: (task) => { q.enqueue(task).catch(() => { }); },
         enqueueAndRun: (task) => q.enqueue(task),
         runAll: () => q.onIdle(),
     };
 }
 function waitRun() {
-    const w = enhancedWaitRun();
+    const w = (0, exports.enhancedWaitRun)();
     return { refreshAsync: w.throttleAsync, refreshAsync2: w.debounceAsync };
 }
 function queueRun(n = 5) {
@@ -91,14 +105,30 @@ function queueRun(n = 5) {
         run: () => q.runAll(),
     };
 }
-function createTaskQueue() {
-    let ready = false;
+function createReadyGate() {
+    let isReadyFlag = false;
     const tasks = [];
+    const setReady = async () => {
+        isReadyFlag = true;
+        const run = tasks.splice(0);
+        let err;
+        for (const fn of run) {
+            try {
+                await fn();
+            }
+            catch (e) {
+                err ??= e;
+            }
+        }
+        if (err !== undefined)
+            throw err;
+    };
     return {
-        add: (fn) => ready ? void fn() : tasks.push(fn),
-        setReady: async () => { ready = true; for (const fn of tasks)
-            await fn(); tasks.length = 0; },
-        isReady: () => ready,
+        add: (fn) => isReadyFlag ? void fn() : tasks.push(fn),
+        ready: setReady,
+        isReady: () => isReadyFlag,
         tasks: () => [...tasks],
+        setReady,
     };
 }
+exports.createTaskQueue = createReadyGate;

package/lib/Common/core/Decorator.d.ts

@@ -11,6 +11,7 @@ type AsyncExtras<T extends (...args: any[]) => any> = ReturnType<T> extends Prom
 } : {};
 type EnhancedDecoratorOptions<T extends (...args: any[]) => any> = CommonOptions<T> & AsyncExtras<T>;
 export declare function enhancedDecorator<T extends (...args: any[]) => any>(fn: T, opt?: EnhancedDecoratorOptions<T>): (...args: Parameters<T>) => ReturnType<T>;
+export declare const wrap: typeof enhancedDecorator;
 export declare function enhancedTransformer<T extends (...args: any[]) => any, R>(fn: T, transform: (data: [args: Parameters<T>, result: ReturnType<T>]) => R): (...args: Parameters<T>) => R;
 export declare function Decorator<T extends (...args: any[]) => any>(fn: T, opt?: {
     parameters?: (...a: Parameters<T>) => any;
@@ -20,5 +21,6 @@ export declare function Decorator<T extends (...args: any[]) => any>(fn: T, opt?
     resultModifier?: (res: ReturnType<T>) => ReturnType<T>;
 }): (...args: Parameters<T>) => ReturnType<T>;
 export declare function TransformerResult<T extends (...args: any[]) => any, R>(fn: T, transform: (data: [args: Parameters<T>, result: ReturnType<T>]) => R): (...args: Parameters<T>) => R;
-export declare function Transformer<T extends (...args: any[]) => any, R>(fn: T, transform: (data: [args: Parameters<T>, fn: T]) => R): (...args: Parameters<T>) => R;
+export declare function around<T extends (...args: any[]) => any, R>(fn: T, transform: (data: [args: Parameters<T>, fn: T]) => R): (...args: Parameters<T>) => R;
+export declare const Transformer: typeof around;
 export {};

package/lib/Common/core/Decorator.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transformer = exports.wrap = void 0;
 exports.enhancedDecorator = enhancedDecorator;
 exports.enhancedTransformer = enhancedTransformer;
 exports.Decorator = Decorator;
 exports.TransformerResult = TransformerResult;
-exports.Transformer = Transformer;
+exports.around = around;
 function enhancedDecorator(fn, opt) {
     return (...args) => {
         opt?.beforeParams?.(...args);
@@ -30,6 +31,7 @@ function enhancedDecorator(fn, opt) {
         }
     };
 }
+exports.wrap = enhancedDecorator;
 function enhancedTransformer(fn, transform) {
     return (...args) => {
         const result = fn(...args);
@@ -48,6 +50,7 @@ function Decorator(fn, opt) {
 function TransformerResult(fn, transform) {
     return enhancedTransformer(fn, transform);
 }
-function Transformer(fn, transform) {
+function around(fn, transform) {
     return (...args) => transform([args, fn]);
 }
+exports.Transformer = around;

package/lib/Common/core/common.d.ts

@@ -7,16 +7,16 @@ type const_Date = Omit<Date, "setTime" | "setFullYear" | "setMonth" | "setDate"
 export declare function isDate<T>(value: T & (Extract<T, const_Date> extends never ? never : T)): value is Extract<typeof value, const_Date>;
 export { Mutable };
 export declare function shallowClone<T>(val: T): Mutable<T>;
-export declare function _deepClone<T>(src: T, map?: Map<object, object>): T;
-export declare function deepClone<T>(object: T): T;
+export declare function _deepClone<T>(src: T, map?: Map<object, object>): any;
+export declare function deepClone<T>(object: T): any;
+export declare const clone: typeof deepClone;
 export declare function deepCloneMutable<T>(value: T): MutableFull<T>;
-export declare function deepCloneObject<T extends object>(object: T): T;
+export declare function deepCloneObject<T extends object>(object: T): any;
 export declare function deepCloneObjectMutable<T extends object>(object: T): MutableFull<T>;
 export declare function toImmutable<T extends object>(object: T): Immutable<T>;
 export declare function readonlyFull<T>(arg: T): ReadonlyFull<T>;
-export declare function deepEqual<T extends {
-    [key: string]: any;
-}>(object1: T, object2: T): boolean;
+export declare function deepEqual(object1: any, object2: any): boolean;
+export declare const isEqual: typeof deepEqual;
 export declare function shallowEqual<T extends {
     [key: string]: unknown;
 } | undefined>(object1: T, object2: T): boolean;
@@ -57,21 +57,28 @@ export declare function BSearchNearest(array: ArrayLike<number>, searchValue: nu
 export declare function BSearchNearest<T>(array: ArrayLike<T>, searchValue: number, arrayGetValue: (element: T) => number, maxDelta?: number): number;
 export declare function _BSearchNearest<T>(array: ArrayLike<T>, searchValue: number, arrayGetValue: (element: T) => number, maxDelta?: number): number;
 export declare function NormalizeDouble(value: number, digits: number): number;
+export declare function round(value: number, digits?: number): number;
 export declare function MaxCommonDivisor(a: number, b: number, digits?: number): number;
 export declare function MaxCommonDivisorOnArray(values: Iterable<number>, precisDigits?: number): number;
+export declare function gcd(a: number, b: number, digits?: number): number;
+export declare function gcd(values: Iterable<number>, digits?: number): number;
 export declare function GetDblPrecision2(value: number, mindigits: number, maxdigits: number): number;
 export declare function GetDblPrecision(value: number, maxdigits?: number): number;
+export declare function decimals(value: number, maxDigits?: number, minDigits?: number): number;
 export declare function DblToStrAuto(value: number, maxprecis?: number): string;
+export declare const formatAuto: typeof DblToStrAuto;
 export declare function NormalizeDoubleAnd(a: number, options?: {
     digitsPoint?: number;
     digitsR?: number;
     type?: "max" | "min";
 }): number;
+export declare const roundSig: typeof NormalizeDoubleAnd;
 export declare function DblToStrAnd(a: number, options?: {
     digitsPoint?: number;
     digitsR?: number;
     type?: "max" | "min";
 }): string;
+export declare const formatSig: typeof DblToStrAnd;
 export declare function ArrayItemHandler<T extends {
     [key: number]: any;
 }>(getter: (target: T, i: number) => T[number], setter?: (target: T, i: number, value: T[number]) => void): ProxyHandler<T>;
@@ -113,17 +120,25 @@ export declare class __MyMap<K extends {
     get sortedKeys(): readonly K[];
     get Values(): readonly V[];
     assign(other: __MyMap<K, V>): void;
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    has(key: K): boolean;
+    delete(key: K): void;
+    clear(): void;
+    get size(): number;
 }
 export declare class MyMap<K extends {
     valueOf(): number;
 }, V> extends __MyMap<K, V> {
     readonly [key: number]: void;
     Clone(): MyMap<K, V>;
+    clone(): MyMap<K, V>;
 }
 export declare class MyNumMap<VAL> extends __MyMap<number, VAL> {
     [key: number]: VAL | undefined;
     constructor();
     Clone(): MyNumMap<VAL>;
+    clone(): MyNumMap<VAL>;
 }
 export declare class StructMap<TKey extends (Required<TKey> & {
     [key: string]: number | string;
@@ -187,9 +202,10 @@ export declare class CancelToken implements ICancelToken {
     private _cancel;
     isCancelled(): boolean;
     cancel(): void;
+    get aborted(): boolean;
+    abort(): void;
 }
 export declare class CancelablePromise<T> extends Promise<T> {
-    private static _rejectTmp;
     private readonly _reject?;
     private readonly _onCancel?;
     constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void, onCancel?: () => void);
@@ -209,6 +225,7 @@ export declare class Mutex {
     private mutex;
     lock(): PromiseLike<() => void>;
     dispatch<T>(fn: () => T | PromiseLike<T>): Promise<T>;
+    runExclusive<T>(fn: () => T | PromiseLike<T>): Promise<T>;
     static createLock(): PromiseLike<() => void>;
 }
 export declare function copyToClipboard(textToCopy: string): Promise<any>;
@@ -232,6 +249,7 @@ export declare class MapExt<K, V> extends Map<K, V> {
     private immutArray?;
     set(key: K, value: V): this;
     delete(key: K): boolean;
+    clear(): void;
     valuesArrayImmutable(): readonly V[];
     getOrSetFunc(key: K, val: () => V): V;
     getOrSet(key: K, val: V): V;

package/lib/Common/core/common.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CCachedValue2 = exports.CCachedValueT = exports.WeakMapExt = exports.MapExt = exports.CObjectID = exports.Mutex = exports.MyTimerInterval = exports.CancelablePromise = exports.CancelToken = exports.VirtualItems = exports.ArraySet = exports.ArrayMap = exports.StructSet = exports.StructMap = exports.MyNumMap = exports.MyMap = exports.__MyMap = exports.BSearchAsync = exports.E_MATCH = exports.E_SORTMODE = exports.CBase = void 0;
+exports.CCachedValue2 = exports.CCachedValueT = exports.WeakMapExt = exports.MapExt = exports.CObjectID = exports.Mutex = exports.MyTimerInterval = exports.CancelablePromise = exports.CancelToken = exports.VirtualItems = exports.ArraySet = exports.ArrayMap = exports.StructSet = exports.StructMap = exports.MyNumMap = exports.MyMap = exports.__MyMap = exports.formatSig = exports.roundSig = exports.formatAuto = exports.BSearchAsync = exports.E_MATCH = exports.E_SORTMODE = exports.CBase = exports.isEqual = exports.clone = void 0;
 exports.GetEnumKeys = GetEnumKeys;
 exports.isDate = isDate;
 exports.shallowClone = shallowClone;
@@ -55,10 +55,13 @@ exports.BSearchValueInRange = BSearchValueInRange;
 exports.BSearchNearest = BSearchNearest;
 exports._BSearchNearest = _BSearchNearest;
 exports.NormalizeDouble = NormalizeDouble;
+exports.round = round;
 exports.MaxCommonDivisor = MaxCommonDivisor;
 exports.MaxCommonDivisorOnArray = MaxCommonDivisorOnArray;
+exports.gcd = gcd;
 exports.GetDblPrecision2 = GetDblPrecision2;
 exports.GetDblPrecision = GetDblPrecision;
+exports.decimals = decimals;
 exports.DblToStrAuto = DblToStrAuto;
 exports.NormalizeDoubleAnd = NormalizeDoubleAnd;
 exports.DblToStrAnd = DblToStrAnd;
@@ -95,36 +98,43 @@ function shallowClone(val) {
 function _deepClone(src, map) {
     if (!src || typeof src != "object")
         return src;
+    const srcObj = src;
+    const cached = map?.get(srcObj);
+    if (cached)
+        return cached;
+    const cloneValue = (value) => value && typeof value == "object"
+        ? _deepClone(value, map)
+        : typeof value == "function"
+            ? value.bind(newobject)
+            : value;
     let newobject = src instanceof Array ? [] : {};
-    if (src instanceof Set)
-        newobject = new Set(src.values());
-    else if (src instanceof Map)
-        newobject = new Map(src.entries());
-    else { }
-    if (src instanceof Date)
+    map ??= new Map();
+    map.set(srcObj, newobject);
+    if (src instanceof Date) {
         newobject = new Date(src);
-    let first = true;
-    function getMap() {
-        map ??= new Map();
-        if (first) {
-            map.set(src, newobject);
-            first = false;
-        }
-        return map;
-    }
-    function mapGetOrSet(key, valFunc) { let val = map?.get(key); if (!val)
-        getMap().set(key, val = valFunc()); return val; }
-    for (let [key, value] of Object.entries(src)) {
-        newobject[key] =
-            typeof (value) == "object"
-                ? mapGetOrSet(value, () => _deepClone(value, map))
-                : typeof (value) == "function"
-                    ? value.bind(newobject)
-                    : value;
-    }
+        map.set(srcObj, newobject);
+        return newobject;
+    }
+    if (src instanceof Set) {
+        newobject = new Set();
+        map.set(srcObj, newobject);
+        for (const value of src)
+            newobject.add(cloneValue(value));
+        return newobject;
+    }
+    if (src instanceof Map) {
+        newobject = new Map();
+        map.set(srcObj, newobject);
+        for (const [key, value] of src)
+            newobject.set(cloneValue(key), cloneValue(value));
+        return newobject;
+    }
+    for (let [key, value] of Object.entries(src))
+        newobject[key] = cloneValue(value);
     return newobject;
 }
 function deepClone(object) { return _deepClone(object); }
+exports.clone = deepClone;
 function deepCloneMutable(value) { return deepClone(value); }
 function deepCloneObject(object) {
     if (object == undefined)
@@ -140,6 +150,30 @@ function readonlyFull(arg) { return arg; }
 function deepEqual(object1, object2) {
     if (object1 == object2)
         return true;
+    if (object1 == null || object2 == null)
+        return false;
+    if (typeof object1 != "object" || typeof object2 != "object")
+        return false;
+    if (object1.constructor !== object2.constructor)
+        return false;
+    if (object1 instanceof Date)
+        return object1.getTime() === object2.getTime();
+    if (object1 instanceof Map) {
+        if (object1.size !== object2.size)
+            return false;
+        for (const [k, v] of object1)
+            if (!object2.has(k) || !deepEqual(v, object2.get(k)))
+                return false;
+        return true;
+    }
+    if (object1 instanceof Set) {
+        if (object1.size !== object2.size)
+            return false;
+        for (const v of object1)
+            if (!object2.has(v))
+                return false;
+        return true;
+    }
     const keys1 = Object.keys(object1);
     const keys2 = Object.keys(object2);
     if (keys1.length != keys2.length)
@@ -155,6 +189,7 @@ function deepEqual(object1, object2) {
     }
     return true;
 }
+exports.isEqual = deepEqual;
 function shallowEqual(object1, object2) {
     if (!object1 || !object2)
         return object1 == object2;
@@ -326,17 +361,18 @@ function _BSearchNearest(array, searchValue, arrayGetValue, maxDelta) {
     return index;
 }
 function NormalizeDouble(value, digits) { let factor = 10 ** digits; return Math.round(value * factor) / factor; }
+function round(value, digits = 0) { return NormalizeDouble(value, digits); }
 function fabs(value) { return Math.abs(value); }
-function round(value) { return Math.round(value); }
+function roundInt(value) { return Math.round(value); }
 function __GetMaxCommonDivisor(a, b, digits) {
     let precis = 0.1 ** (digits) / 2;
     while (true) {
         if (b < precis)
             return NormalizeDouble(a, digits);
-        a = fabs(a - round(a / b) * b);
+        a = fabs(a - roundInt(a / b) * b);
         if (a < precis)
             return NormalizeDouble(b, digits);
-        b = fabs(b - round(b / a) * a);
+        b = fabs(b - roundInt(b / a) * a);
     }
 }
 function __GetMaxCommonDivisorInteger(a, b) {
@@ -372,6 +408,11 @@ function MaxCommonDivisorOnArray(values, precisDigits = 8) {
     }
     return divis;
 }
+function gcd(a, b, digits) {
+    if (typeof a == "number")
+        return MaxCommonDivisor(a, b, digits ?? 8);
+    return MaxCommonDivisorOnArray(a, b ?? 8);
+}
 function GetDblPrecision2(value, mindigits, maxdigits) {
     maxdigits = Math.min(maxdigits, 16);
     let epsilon = Math.pow(0.1, maxdigits + 1);
@@ -386,6 +427,7 @@ function GetDblPrecision2(value, mindigits, maxdigits) {
 }
 ;
 function GetDblPrecision(value, maxdigits = 8) { return GetDblPrecision2(value, 0, maxdigits); }
+function decimals(value, maxDigits = 8, minDigits = 0) { return GetDblPrecision2(value, minDigits, maxDigits); }
 function DblToStrAuto2(value, minprecis, maxprecis) { return value?.toFixed(GetDblPrecision2(value, minprecis, maxprecis)); }
 function DblToStrAuto(value, maxprecis = 8) {
     let digits = maxprecis;
@@ -396,6 +438,7 @@ function DblToStrAuto(value, maxprecis = 8) {
             maxprecis = 0;
     return DblToStrAuto2(value, 0, maxprecis);
 }
+exports.formatAuto = DblToStrAuto;
 function NormalizeDoubleAnd(a, options) {
     if (a == 0)
         return a;
@@ -414,6 +457,7 @@ function NormalizeDoubleAnd(a, options) {
         return func(a / (10 ** (k - w))) * (10 ** (k - w));
     return func(a / (10 ** (k - w))) * (10 ** (k - w));
 }
+exports.roundSig = NormalizeDoubleAnd;
 function DblToStrAnd(a, options) {
     let { digitsPoint: w = 4, digitsR: r } = options ?? {};
     if (!r && a % 1.0 == 0)
@@ -431,6 +475,7 @@ function DblToStrAnd(a, options) {
         return (func(a / (10 ** (k - w + 1))) * (10 ** (k - w + 1))).toString();
     return (func(a / (10 ** (k - w + 1))) * (10 ** (k - w + 1))).toFixed(w - k - 1);
 }
+exports.formatSig = DblToStrAnd;
 function testDblToStrAnd() {
     const r = 0.047952487787;
     for (let i = -10; i < 10; i++) {
@@ -519,10 +564,17 @@ class __MyMap {
     get Values() { if (!this.keys)
         this.createArrays(); return this.values; }
     assign(other) { this.map = other.map.clone(); this.keys = other.keys; this.values = other.values; }
+    set(key, value) { this.Set(key, value); }
+    get(key) { return this.Get(key); }
+    has(key) { return this.Contains(key); }
+    delete(key) { this.Remove(key); }
+    clear() { this.Clear(); }
+    get size() { return this.Count(); }
 }
 exports.__MyMap = __MyMap;
 class MyMap extends __MyMap {
     Clone() { let newobj = new MyMap(); newobj.assign(this); return newobj; }
+    clone() { return this.Clone(); }
 }
 exports.MyMap = MyMap;
 class MyNumMap extends __MyMap {
@@ -531,6 +583,7 @@ class MyNumMap extends __MyMap {
         return CreateArrayProxy(this, (i) => this.Get(i), (key, value) => this.Set(key, value ?? (() => { throw new Error("undefined value"); })()));
     }
     Clone() { let newobj = new MyNumMap(); newobj.assign(this); return newobj; }
+    clone() { return this.Clone(); }
 }
 exports.MyNumMap = MyNumMap;
 class StructMap {
@@ -563,7 +616,20 @@ class StructMap {
         }
         return obj;
     }
-    has(key) { return this.get(key) != null; }
+    has(key) {
+        let items = key instanceof Array ? key : Object.values(key);
+        if (items.length == 0)
+            return false;
+        let obj = this._data;
+        for (let item of items) {
+            if (typeof obj != "object" && typeof obj != "function")
+                return false;
+            if (obj == null || !(item in obj))
+                return false;
+            obj = obj[item];
+        }
+        return true;
+    }
     keys() { return this._keys; }
     values() { return this._values; }
     *entries() { for (let [i, key] of this._keys.entries())
@@ -606,15 +672,17 @@ class CancelToken {
     _cancel = false;
     isCancelled() { return this._cancel; }
     cancel() { this._cancel = true; }
+    get aborted() { return this.isCancelled(); }
+    abort() { this.cancel(); }
 }
 exports.CancelToken = CancelToken;
 class CancelablePromise extends Promise {
-    static _rejectTmp;
     _reject;
     _onCancel;
     constructor(executor, onCancel) {
-        super((resolve, reject) => { CancelablePromise._rejectTmp = reject; executor(resolve, reject); });
-        this._reject = CancelablePromise._rejectTmp;
+        let rejectCaptured;
+        super((resolve, reject) => { rejectCaptured = reject; executor(resolve, reject); });
+        this._reject = rejectCaptured;
         this._onCancel = onCancel;
     }
     cancel(msg) { if (this._onCancel)
@@ -674,6 +742,7 @@ class Mutex {
             unlock();
         }
     }
+    runExclusive(fn) { return this.dispatch(fn); }
     static createLock() { return (new Mutex).lock(); }
 }
 exports.Mutex = Mutex;
@@ -716,11 +785,22 @@ class CObjectID {
 }
 exports.CObjectID = CObjectID;
 const stringifyDefault = JSON.stringify;
-JSON.stringify = (value, replacer, space) => stringifyDefault(value, (key, val) => val instanceof CObjectID ? val.value + "" : typeof replacer == "function" ? replacer(key, val) : val, space);
+JSON.stringify = (value, replacer, space) => {
+    const allow = Array.isArray(replacer)
+        ? new Set(replacer.filter(v => typeof v == "string" || typeof v == "number").map(String))
+        : null;
+    return stringifyDefault(value, (key, val) => {
+        if (allow && key !== "" && !allow.has(key))
+            return undefined;
+        const next = val instanceof CObjectID ? val.value + "" : val;
+        return typeof replacer == "function" ? replacer(key, next) : next;
+    }, space);
+};
 class MapExt extends Map {
     immutArray;
     set(key, value) { this.immutArray = undefined; return super.set(key, value); }
     delete(key) { this.immutArray = undefined; return super.delete(key); }
+    clear() { this.immutArray = undefined; return super.clear(); }
     valuesArrayImmutable() { return this.immutArray ??= [...this.values()]; }
     getOrSetFunc(key, val) {
         let v = this.get(key);

package/lib/Common/data/ByteStream.d.ts

@@ -39,7 +39,7 @@ export declare class ByteStreamW {
     pushNumber(value: number, type: NumericTypes | Nullable<NumericTypes>): boolean;
     pushNumbers(values: readonly number[], type: NumericTypes | Nullable<NumericTypes>): this | null;
     pushArrayByFunc<T>(array: Iterable<T>, func: (stream: ByteStreamW, item: T) => boolean | void, maxlength?: number): this | null;
-    protected _getWriteFuncForNumeric(type: NumericTypes | Nullable<NumericTypes>): (stream: ByteStreamW, value: number) => boolean;
+    protected _getWriteFuncForNumeric(type: NumericTypes | Nullable<NumericTypes>): (stream: ByteStreamW, value: number | null) => boolean;
     pushArrayNumeric(array: Iterable<number>, type: NumericTypes | Nullable<NumericTypes>, maxlength?: number): this | null;
     pushArray<T extends WritableToBytes>(array: Iterable<T> | Int8Array | Uint8Array, maxlength?: number): this | null;
     pushArrayOfNullable<T extends WritableToBytes | null>(array: Iterable<T>, maxlength?: number): this | null;