wenay-common2 1.0.45 → 1.0.48

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;
@@ -290,9 +325,9 @@ function BSearchValueInRange(from, to, precision, compare, matchMode) {
     if (precision == 0)
         throw new Error("precision=0");
     let count = Math.round((to - from) / precision) + 1;
-    const sortMode = count >= 0 ? 1 : -1;
+    const sortMode = precision > 0 ? E_SORTMODE.ASCEND : E_SORTMODE.DESCEND;
     count = Math.abs(count);
-    let i = BSearchIndex(count, (index) => compare(from + precision * index), matchMode);
+    let i = BSearchIndex(count, (index) => compare(from + precision * index), matchMode, sortMode);
     if (i == -1)
         return null;
     return from + precision * i;
@@ -311,7 +346,7 @@ function _BSearchNearest(array, searchValue, arrayGetValue, maxDelta) {
     let indexes = [];
     if (i == -1)
         i = array.length - 1;
-    else if (i >= 0)
+    else if (i > 0)
         indexes.push(i - 1);
     indexes.push(i);
     let delta = maxDelta ?? Number.MAX_VALUE;
@@ -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++) {
@@ -506,7 +551,7 @@ class __MyMap {
     Set(key, value) { this.map[key.valueOf()] = { key, value }; this.keys = null; this.OnModify?.(key); }
     Get(key) { let pair = this.map[key.valueOf()]; return pair ? pair.value : undefined; }
     Contains(key) { return this.map[key.valueOf()] != undefined; }
-    TryAdd(key, value) { if (!this.Contains(key))
+    TryAdd(key, value) { if (this.Contains(key))
         return false; this.Set(key, value); return true; }
     Add(key, value) { if (!this.TryAdd(key, value))
         throw new Error(`Key ${key} is already exists for ${typeof value}`); }
@@ -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;

package/lib/Common/data/ByteStream.js

@@ -4,7 +4,10 @@ exports.ByteStreamR = exports.ByteStreamW = exports.Nullable = void 0;
 exports.nullable = nullable;
 function createCopyOfBuffer(src, length = src.byteLength) {
     let dst = new ArrayBuffer(length);
-    new Uint8Array(dst).set(new Uint8Array(src));
+    const bytes = src instanceof DataView
+        ? new Uint8Array(src.buffer, src.byteOffset, Math.min(src.byteLength, length))
+        : new Uint8Array(src, 0, Math.min(src.byteLength, length));
+    new Uint8Array(dst).set(bytes);
     return dst;
 }
 class Nullable {
@@ -45,7 +48,7 @@ class ByteStreamW {
     _isThrowable = true;
     _buffer() { return this._view?.buffer; }
     resize(size) {
-        let buf = createCopyOfBuffer(this._buffer(), size);
+        let buf = createCopyOfBuffer(this._view, size);
         this._view = new DataView(buf);
     }
     constructor(view) {
@@ -57,7 +60,7 @@ class ByteStreamW {
         }
     }
     get length() { return this._pos; }
-    get data() { return new DataView(this._buffer(), 0, this._pos); }
+    get data() { return new DataView(this._buffer(), this._view.byteOffset, this._pos); }
     noThrow() { let other = new ByteStreamW(this._view); other._pos = this._pos; other._isThrowable = false; return other; }
     _ensureAllocation(bytes) {
         let minSize = this._pos + bytes;
@@ -73,18 +76,9 @@ class ByteStreamW {
                 }
             }
     }
-    _setInt8(pos, value) { if ((value & 1 << 7) != 0)
-        this._view.setInt8(pos, value);
-    else
-        this._view.setUint8(pos, value); }
-    _setInt16(pos, value) { if ((value & 1 << 15) != 0)
-        this._view.setInt16(pos, value);
-    else
-        this._view.setUint16(pos, value); }
-    _setInt32(pos, value) { if ((value & 1 << 31) != 0)
-        this._view.setInt32(pos, value);
-    else
-        this._view.setUint32(pos, value); }
+    _setInt8(pos, value) { this._view.setInt8(pos, value); }
+    _setInt16(pos, value) { this._view.setInt16(pos, value); }
+    _setInt32(pos, value) { this._view.setInt32(pos, value); }
     _push(value, bytes, isInteger) {
         let pos = this._pos;
         this._ensureAllocation(bytes);
@@ -110,11 +104,11 @@ class ByteStreamW {
                     break;
                 case 6:
                     this._setInt32(pos, value);
-                    this._setInt16(pos + 4, value / 0x10000000);
+                    this._setInt16(pos + 4, Math.floor(value / 0x100000000));
                     break;
                 case 8:
                     this._setInt32(pos, value);
-                    this._setInt32(pos + 4, value / 0x10000000);
+                    this._setInt32(pos + 4, Math.floor(value / 0x100000000));
                     break;
                 default: throw ("Wrong byte length: " + bytes);
             }
@@ -175,7 +169,15 @@ class ByteStreamW {
         let typeInfo = getNumericTypeInfo(type);
         if (!typeInfo)
             throw ("Wrong type: " + type);
-        return (stream, value) => { return (isNullable ? stream.pushBool(value != null) : stream)?._push(value, typeInfo.size, typeInfo.integer) != null; };
+        return (stream, value) => {
+            if (isNullable) {
+                if (stream.pushBool(value != null) == null)
+                    return false;
+                if (value == null)
+                    return true;
+            }
+            return stream._push(value, typeInfo.size, typeInfo.integer) != null;
+        };
     }
     pushArrayNumeric(array, type, maxlength) {
         return this.pushArrayByFunc(array, this._getWriteFuncForNumeric(type), maxlength);
@@ -186,10 +188,7 @@ class ByteStreamW {
             this._ensureAllocation(length + 4);
             this.pushInt32(length);
             let arrayClass = (array instanceof Int8Array) ? Int8Array : Uint8Array;
-            if (length != array.length) {
-                array = new arrayClass(array.buffer, 0, length);
-            }
-            new arrayClass(this._buffer()).set(array, this._pos);
+            new arrayClass(this._buffer(), this._view.byteOffset + this._pos, length).set(array.subarray(0, length));
             this._pos += length;
             return this;
         }
@@ -259,10 +258,10 @@ class ByteStreamR_ {
                     switch (bytes) {
                         case 1: return view.getInt8(pos);
                         case 2: return view.getInt16(pos);
-                        case 3: return view.getInt16(pos) | (view.getInt8(pos + 2) << 16);
+                        case 3: return view.getUint16(pos) + (view.getInt8(pos + 2) << 16);
                         case 4: return view.getInt32(pos);
-                        case 6: return view.getInt32(pos) | view.getInt16(pos + 4) * 0x10000000;
-                        case 8: return view.getInt32(pos) | view.getInt32(pos + 4) * 0x10000000;
+                        case 6: return view.getUint32(pos) + view.getInt16(pos + 4) * 0x100000000;
+                        case 8: return view.getUint32(pos) + view.getInt32(pos + 4) * 0x100000000;
                     }
                 }
                 else {
@@ -271,8 +270,8 @@ class ByteStreamR_ {
                         case 2: return view.getUint16(pos);
                         case 3: return view.getUint16(pos) | (view.getUint8(pos + 2) << 16);
                         case 4: return view.getUint32(pos);
-                        case 6: return view.getUint32(pos) | view.getUint16(pos + 4) * 0x10000000;
-                        case 8: return view.getUint32(pos) | view.getUint32(pos + 4) * 0x10000000;
+                        case 6: return view.getUint32(pos) + view.getUint16(pos + 4) * 0x100000000;
+                        case 8: return view.getUint32(pos) + view.getUint32(pos + 4) * 0x100000000;
                     }
                 }
             }
@@ -350,6 +349,11 @@ class ByteStreamR_ {
             let size = this.readUint32();
             if (size == null)
                 return null;
+            if (this._pos + size > this._view.byteLength)
+                if (this.isThrowable)
+                    throw ("Array read out of range");
+                else
+                    return null;
             let bufpos = this._view.byteOffset + this._pos;
             const out = new arrayClass(this._view.buffer.slice(bufpos, bufpos + size));
             this._pos += size;

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

@@ -24,13 +24,14 @@ export declare class CList<T, TNode extends ListNode<T> = ListNode<T>> implement
     get last(): CListNode<T> | undefined;
     get count(): number;
     get length(): number;
+    get size(): number;
     readonly [Symbol.iterator]: () => Generator<TNode, void, unknown>;
     constructor(values?: Iterable<T>);
     nodes(): Generator<TNode, void, unknown>;
     values(): Generator<T, void, unknown>;
     reversedNodes(): Generator<TNode, void, unknown>;
     reversedValues(): Generator<T, void, unknown>;
-    entries(): Generator<never, () => Generator<TNode, void, unknown>, unknown>;
+    entries(): Generator<readonly [number, T], void, unknown>;
     next(node: ListNode<T>): TNode | undefined;
     prev(node: ListNode<T>): TNode | undefined;
     find(value: T): TNode | undefined;
@@ -53,6 +54,10 @@ export declare class CList<T, TNode extends ListNode<T> = ListNode<T>> implement
     delete(node: ListNode<T>): void;
     deleteFirst(): void;
     deleteLast(): void;
+    push(value: T): ListNode<T>;
+    unshift(value: T): ListNode<T>;
+    pop(): T | undefined;
+    shift(): T | undefined;
     clear(): void;
     private validateNode;
     private newNode;

package/lib/Common/data/List.js

@@ -18,18 +18,24 @@ class CList {
     get last() { return this._last; }
     get count() { return this._count; }
     get length() { return this._count; }
+    get size() { return this._count; }
     [Symbol.iterator] = this.nodes;
     constructor(values = []) { for (let value of values)
         this.add(value); }
-    *nodes() { for (let node = this._first, next = node?.next; node != null; node = next, next = next?.next)
-        yield node; }
+    *nodes() { for (let node = this._first; node != null;) {
+        yield node;
+        node = node.next;
+    } }
     *values() { for (let node of this)
         yield node.value; }
-    *reversedNodes() { for (let node = this._last, next = node?.prev; node != null; node = next, next = next?.prev)
-        yield node; }
+    *reversedNodes() { for (let node = this._last; node != null;) {
+        yield node;
+        node = node.prev;
+    } }
     *reversedValues() { for (let node of this.reversedNodes())
         yield node.value; }
-    *entries() { return this.nodes; }
+    *entries() { let i = 0; for (let node of this.nodes())
+        yield [i++, node.value]; }
     next(node) { return this.validateNode(node) ? node.next : (() => { throw "Wrong node list"; })(); }
     ;
     prev(node) { return this.validateNode(node) ? node.prev : (() => { throw "Wrong node list"; })(); }
@@ -102,7 +108,16 @@ class CList {
         let newNode = this.newNode(value);
         newNode.next = node.next;
         newNode.prev = node.prev;
+        if (node.prev)
+            node.prev.next = newNode;
+        else
+            this._first = newNode;
+        if (node.next)
+            node.next.prev = newNode;
+        else
+            this._last = newNode;
         node.list = undefined;
+        node.next = node.prev = undefined;
         this._immutableList = undefined;
         return newNode;
     }
@@ -133,9 +148,16 @@ class CList {
         this.delete(this._first); }
     deleteLast() { if (this._last)
         this.delete(this._last); }
+    push(value) { return this.addLast(value); }
+    unshift(value) { return this.addFirst(value); }
+    pop() { let value = this._last?.value; this.deleteLast(); return value; }
+    shift() { let value = this._first?.value; this.deleteFirst(); return value; }
     clear() {
         for (let node = this._first; node != null; node = node.next)
-            this.delete(node);
+            node.list = undefined;
+        this._first = this._last = undefined;
+        this._count = 0;
+        this._immutableList = undefined;
     }
     validateNode(node) {
         if (!(node instanceof CListNode))

package/lib/Common/data/ListNodeAnd.js

@@ -68,12 +68,12 @@ class CListNodeAnd extends CBaseList {
     isForbidden() { return this._stop; }
     isExists() { return this.isForbidden() || this._prev._stop || this._next._stop; }
     static _Add(prev, next, home, a) { let buf = new CListNodeAnd(prev, next, home); buf.data = a; return buf; }
-    AddNext(a) { return a instanceof CListNodeAnd ? a._Init(this, this._next, this) : a ? CListNodeAnd._Add(this, this._next, this._home, a) : new CListNodeAnd(this, this._next); }
-    AddPrev(a) { return a instanceof CListNodeAnd ? a._Init(this._prev, this, this) : a ? CListNodeAnd._Add(this._prev, this, this._home, a) : new CListNodeAnd(this._prev, this); }
+    AddNext(a) { return a instanceof CListNodeAnd ? a._Init(this, this._next, this) : arguments.length ? CListNodeAnd._Add(this, this._next, this._home, a) : new CListNodeAnd(this, this._next); }
+    AddPrev(a) { return a instanceof CListNodeAnd ? a._Init(this._prev, this, this) : arguments.length ? CListNodeAnd._Add(this._prev, this, this._home, a) : new CListNodeAnd(this._prev, this); }
     AddEnd(a) { return this._stop ? this.AddPrev(a) : this._End().AddNext(a); }
     AddStart(a) { return this._stop ? this.AddNext(a) : this._First().AddPrev(a); }
     forEach(el) {
-        for (let buf = this.First(); buf?.data && !buf.isForbidden();) {
+        for (let buf = this.First(); buf && !buf.isForbidden();) {
             let t = buf.Next();
             el(buf.data, buf);
             buf = t;

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

@@ -2,10 +2,14 @@ export type ObjectKeyPath<TObject extends object = object, TValue = unknown> = r
 export declare function objectSetValueByPath<TObj extends {
     [key: string]: any;
 }, TVal>(obj: TObj, path: ObjectKeyPath<TObj, TVal>, value: TVal): void;
+export declare const objectSet: typeof objectSetValueByPath;
 export declare function objectGetValueByPath<TObj extends {
     readonly [key: string]: any;
 }, TVal>(object: TObj, path: ObjectKeyPath<TObj, TVal>): TVal;
+export declare const objectGet: typeof objectGetValueByPath;
 export declare function objectDeleteValueByPath<TObj extends {
     readonly [key: string]: any;
 }, TVal>(object: TObj, path: ObjectKeyPath<TObj, TVal>): boolean;
+export declare const objectUnset: typeof objectDeleteValueByPath;
 export declare function iterateDeepObjectEntries<TObj extends object>(obj: TObj, filter?: (key: string, value: unknown, path: ObjectKeyPath<TObj>) => boolean, currentPath?: ObjectKeyPath<TObj>): Generator<[key: string, value: unknown, path: ObjectKeyPath<TObj>]>;
+export declare const deepEntries: typeof iterateDeepObjectEntries;

package/lib/Common/data/objectPath.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.deepEntries = exports.objectUnset = exports.objectGet = exports.objectSet = void 0;
 exports.objectSetValueByPath = objectSetValueByPath;
 exports.objectGetValueByPath = objectGetValueByPath;
 exports.objectDeleteValueByPath = objectDeleteValueByPath;
@@ -13,10 +14,11 @@ function objectSetValueByPath(obj, path, value) {
         return;
     }
     let val = obj[key];
-    if (typeof val != "object")
+    if (val == null || typeof val != "object")
         throw "value is not an object: " + val;
     return objectSetValueByPath(val, path.slice(1), value);
 }
+exports.objectSet = objectSetValueByPath;
 function objectGetValueByPath(object, path) {
     if (path.length == 0)
         throw "empty path!";
@@ -26,10 +28,11 @@ function objectGetValueByPath(object, path) {
     let val = object[key];
     if (path.length == 1)
         return val;
-    if (typeof val != "object")
+    if (val == null || typeof val != "object")
         throw "value is not an object: " + val;
     return objectGetValueByPath(val, path.slice(1));
 }
+exports.objectGet = objectGetValueByPath;
 function objectDeleteValueByPath(object, path) {
     if (path.length == 0)
         throw "empty path!";
@@ -42,10 +45,11 @@ function objectDeleteValueByPath(object, path) {
             return true;
         }
     let val = object[key];
-    if (typeof val != "object")
+    if (val == null || typeof val != "object")
         throw "value is not an object: " + val;
     return objectDeleteValueByPath(val, path.slice(1));
 }
+exports.objectUnset = objectDeleteValueByPath;
 function* iterateDeepObjectEntries(obj, filter, currentPath = []) {
     if (obj)
         for (let [key, val] of Object.entries(obj)) {
@@ -57,3 +61,4 @@ function* iterateDeepObjectEntries(obj, filter, currentPath = []) {
                 yield* iterateDeepObjectEntries(val, filter, keyPath);
         }
 }
+exports.deepEntries = iterateDeepObjectEntries;