@avstantso/core 1.2.2 → 1.3.0

package/dist/index.js

@@ -12,11 +12,9 @@ require('@avstantso/std-ext');
  * ⚠ All exported namespace `AVStantso` constants and functions\
  * must be expressed through `avstantso` global variable
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-(() => {
+const avstantso$1 = (() => {
+    const symbolFreeze = Symbol('freeze');
     const RegisterGlobalNamespace = ((namespaceName, statics) => {
-        const structs = ['object', 'function'];
-        const symbolFreeze = Symbol('freeze');
         const singleton = { ...statics };
         /**
          * @summary Register `field`. ⚠ Override not supported now
@@ -44,7 +42,7 @@ require('@avstantso/std-ext');
                 get(target, p) {
                     return p in target
                         ? Reflect.get(target, p)
-                        : p in level
+                        : p in level && Object.isExtensible(level[p])
                             ? RegLevel(level[p])
                             : regField.bind(level, p);
                 }
@@ -54,29 +52,7 @@ require('@avstantso/std-ext');
             delete this._reg;
             delete this.debugState;
             delete this.freeze;
-            const walked = new Set();
-            const hasCustomFreeze = Symbol.Has(symbolFreeze, () => { });
-            function deepFreeze(obj, path = []) {
-                try {
-                    const ti = structs.indexOf(typeof obj);
-                    if (!obj || ti < 0 || walked.has(obj))
-                        return obj;
-                    walked.add(obj);
-                    if (hasCustomFreeze(obj))
-                        return obj[symbolFreeze].call(obj);
-                    const entries = Object.entries(Object.getOwnPropertyDescriptors(obj));
-                    for (const [key, dsc] of entries)
-                        if (ti
-                            ? !(key in deepFreeze) // Except standard function properties
-                            : !Array.isArray(dsc.value))
-                            deepFreeze(dsc.value, [...path, key]);
-                    return Object.freeze(obj);
-                }
-                catch (e) {
-                    throw ('path' in e) ? e : Object.assign(e, { path });
-                }
-            }
-            deepFreeze(this);
+            avstantso$1.DeepOps.freeze(this, { ownProps: true });
         }
         Object.definePropertiesOnce(singleton, {
             _reg: {
@@ -118,10 +94,10 @@ require('@avstantso/std-ext');
     return avs_singleton;
 })();
 
-var AVStantso$5;
+var AVStantso$7;
 (function (AVStantso) {
     /* eslint-disable @typescript-eslint/no-explicit-any */
-    AVStantso.Generic = avstantso._reg.Generic(() => {
+    AVStantso.Generic = avstantso._reg.Generic(({ symbolFreeze }) => {
         function Validator() {
             function validate(value) {
                 return value;
@@ -134,18 +110,51 @@ var AVStantso$5;
         function Cast(from) {
             return from;
         }
-        return {
+        const Generic = {
             Validator,
             validate: Validator(),
-            Cast: Object.assign(Cast, { To: Cast })
+            Cast: Object.assign(Cast, { To: Cast }),
+            [symbolFreeze]() {
+                Object.freeze(Generic);
+            }
         };
+        return Generic;
     });
-})(AVStantso$5 || (AVStantso$5 = {}));
+})(AVStantso$7 || (AVStantso$7 = {}));
 
-var AVStantso$4;
+var AVStantso$6;
 (function (AVStantso) {
+    /* eslint-disable @typescript-eslint/no-unsafe-function-type */
     const fpd = Object.assign({}, Object.getOwnPropertyDescriptors(Function.prototype), Object.getOwnPropertyDescriptors(function () { }));
-    AVStantso.Func = avstantso._reg.Func({
+    const runtimeFuncTypes = [
+        'plain',
+        'async', // adds if generators/async needed
+        'generator', // can't be `new`-called — distinct from plain
+        'class',
+        'arrow',
+        'bound'
+    ];
+    const generatorClasses = [
+        'GeneratorFunction',
+        'AsyncGeneratorFunction'
+    ];
+    AVStantso.Func = avstantso._reg.Func(({ symbolFreeze }) => Object.assign({
+        Types: Object.freeze(Object.fromEntries(runtimeFuncTypes.map((k) => [k, k]))),
+        determineType(func) {
+            const protoDsc = Object.getOwnPropertyDescriptor(func, 'prototype');
+            const ctorName = func.constructor.name;
+            if (!protoDsc)
+                return func.name?.startsWith('bound ')
+                    ? 'bound'
+                    : 'AsyncFunction' === ctorName
+                        ? 'async'
+                        : 'arrow';
+            if (!protoDsc.writable)
+                return 'class';
+            if (generatorClasses.includes(ctorName))
+                return 'generator';
+            return 'plain';
+        },
         OwnPropertyDescriptors: fpd,
         isPropAllowed: Object.assign(function isPropAllowed(propName) {
             return !(propName in fpd);
@@ -163,16 +172,20 @@ var AVStantso$4;
                     return true;
             return false;
         },
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
         Dynamic(name, func) {
             return !process.env.IS_DEV
                 ? func
                 : new Function('func', `return function ${name}(...params){ return func(...params); };`)(func);
         }
-    });
-})(AVStantso$4 || (AVStantso$4 = {}));
+    }, {
+        [symbolFreeze]() {
+            for (const field of Object.values(this))
+                Object.freeze(field);
+        }
+    }));
+})(AVStantso$6 || (AVStantso$6 = {}));
 
-var AVStantso$3;
+var AVStantso$5;
 (function (AVStantso) {
     AVStantso.Catch = avstantso._reg.Catch(() => {
         const catchFilters = [];
@@ -192,28 +205,46 @@ var AVStantso$3;
         };
         return DoCatch;
     });
-})(AVStantso$3 || (AVStantso$3 = {}));
+})(AVStantso$5 || (AVStantso$5 = {}));
 
-var AVStantso$2;
+var AVStantso$4;
 (function (AVStantso) {
-    AVStantso.AtomicObjects = avstantso._reg.AtomicObjects(() => {
+    AVStantso.AtomicObjects = avstantso._reg.AtomicObjects(({ symbolFreeze }) => {
         const classes = new Map();
+        const derivedCache = new Map();
         function register(atomicObjectClass, options) {
             classes.set(atomicObjectClass, options);
+            derivedCache.clear();
+        }
+        function resolve(obj) {
+            const ctor = Object.getPrototypeOf(obj)?.constructor;
+            if (!ctor)
+                return null;
+            if (derivedCache.has(ctor))
+                return derivedCache.get(ctor);
+            for (const [Class, options] of classes.entries())
+                if (obj instanceof Class) {
+                    const d = { Class, ...options };
+                    derivedCache.set(ctor, d);
+                    return d;
+                }
+            derivedCache.set(ctor, null);
+            return null;
         }
         function is(testObject) {
-            if ('object' === typeof testObject)
-                for (const Class of classes.keys())
-                    if (testObject instanceof Class)
-                        return true;
-            return false;
+            return 'object' === typeof testObject
+                && null !== testObject
+                && null !== resolve(testObject);
         }
         function descriptor(param) {
-            const i = ['object', 'string'].indexOf(typeof param);
-            if (i >= 0)
+            if ('string' === typeof param) {
                 for (const [Class, options] of classes.entries())
-                    if (i ? param === Class.name : param instanceof Class)
+                    if (param === Class.name)
                         return { Class, ...options };
+                return;
+            }
+            if ('object' === typeof param && null !== param)
+                return resolve(param) ?? undefined;
         }
         register(Date, {
             empty: () => new Date(0),
@@ -225,11 +256,14 @@ var AVStantso$2;
                 empty: () => Buffer.from(''),
                 clone: (instance) => Buffer.from(instance)
             });
-        return { classes, register, is, descriptor };
+        return Object.assign({ classes, register, is, descriptor }, { [symbolFreeze]() {
+                for (const field of Object.values(this))
+                    Object.freeze(field);
+            } });
     });
-})(AVStantso$2 || (AVStantso$2 = {}));
+})(AVStantso$4 || (AVStantso$4 = {}));
 
-var AVStantso$1;
+var AVStantso$3;
 (function (AVStantso) {
     /* eslint-disable @typescript-eslint/no-explicit-any */
     /**
@@ -237,12 +271,500 @@ var AVStantso$1;
      * @returns `undefined`
      */
     AVStantso.X = avstantso._reg.X(() => function X() { });
+})(AVStantso$3 || (AVStantso$3 = {}));
+
+var AVStantso$2;
+(function (AVStantso) {
+    const JSStucturalTypes = Object.freeze(['object', 'function']);
+    let TypeGroupEnum;
+    (function (TypeGroupEnum) {
+        /**
+         * `foo === null || !JSStucturalTypes.includes(typeof foo)`
+         */
+        TypeGroupEnum[TypeGroupEnum["scalar"] = 0] = "scalar";
+        /**
+         * `AVStantso.AtomicObjects.is(foo)`
+         */
+        TypeGroupEnum[TypeGroupEnum["atomic"] = 1] = "atomic";
+        /**
+         * `typeof foo === 'object' && Object.isPlainObject(foo)`
+         */
+        TypeGroupEnum[TypeGroupEnum["plain"] = 2] = "plain";
+        /**
+         * `typeof foo === 'object' && !Object.isPlainObject(foo)`
+         */
+        TypeGroupEnum[TypeGroupEnum["rich"] = 3] = "rich";
+        /**
+         * `typeof foo === 'function'`
+         */
+        TypeGroupEnum[TypeGroupEnum["func"] = 4] = "func";
+    })(TypeGroupEnum || (TypeGroupEnum = {}));
+    Object.freeze(TypeGroupEnum);
+    const TypeGroups = Object.freeze([
+        'scalar',
+        'atomic',
+        'plain',
+        'rich',
+        'func'
+    ]);
+    AVStantso.LowLevel = avstantso._reg.LowLevel(({ AtomicObjects }) => {
+        function typeGroupOf(a) {
+            if (null === a)
+                return TypeGroupEnum.scalar;
+            const t = typeof a;
+            const i = JSStucturalTypes.indexOf(t);
+            if (i < 0)
+                return TypeGroupEnum.scalar;
+            if (i)
+                return TypeGroupEnum.func;
+            if (AtomicObjects.is(a))
+                return TypeGroupEnum.atomic;
+            return Object.isPlainObject(a) ? TypeGroupEnum.plain : TypeGroupEnum.rich;
+        }
+        return {
+            JSStucturalTypes,
+            TypeGroup: TypeGroupEnum,
+            TypeGroups,
+            typeGroupOf
+        };
+    });
+})(AVStantso$2 || (AVStantso$2 = {}));
+
+var AVStantso$1;
+(function (AVStantso) {
+    /* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-function-type */
+    const symbolClone = Symbol('clone');
+    const symbolMerge = Symbol('merge');
+    AVStantso.DeepOps = avstantso._reg.DeepOps(({ symbolFreeze, Func, AtomicObjects, LowLevel }) => {
+        function nodeTypePrefix(nodeType) {
+            return `walk${nodeType.toCapitalized()}`;
+        }
+        function AllowsClassMap(...classes) {
+            return new Map(classes.map((c) => [c, true]));
+        }
+        //#region shared node helpers
+        function nodeTypeOf(value) {
+            return LowLevel.TypeGroups[LowLevel.typeGroupOf(value)];
+        }
+        /**
+         * @summary Resolve a single `walk{NodeType}Inc`/`walk{NodeType}Exc` rule against `value`
+         */
+        function resolveWalkRule(_options, nodeType, value) {
+            function resolve(behavior, fallback) {
+                if (null == behavior)
+                    return { walk: fallback };
+                if ('boolean' === typeof behavior)
+                    return { walk: behavior };
+                if ('function' === typeof behavior)
+                    return { walk: true, custom: behavior };
+                return { walk: fallback };
+            }
+            const p = nodeTypePrefix(nodeType);
+            const isInc = `${p}Inc` in _options;
+            const raw = isInc ? _options[`${p}Inc`] : _options[`${p}Exc`];
+            const fallback = isInc;
+            if (null == raw || 'boolean' === typeof raw || 'function' === typeof raw)
+                return resolve(raw, fallback);
+            if (raw instanceof Map) {
+                const ctor = value?.constructor;
+                return resolve(ctor && raw.has(ctor) ? raw.get(ctor) : undefined, fallback);
+            }
+            const subKey = 'scalar' === nodeType
+                ? (null === value ? 'null' : typeof value)
+                : Func.determineType(value);
+            return resolve(subKey in raw ? raw[subKey] : undefined, fallback);
+        }
+        /**
+         * @summary Iterate `[key, value, descriptor?]` entries of a `plain`/`func` node
+         */
+        function* plainEntries(value, ownProps, isFunc) {
+            if (!ownProps) {
+                for (const kv of Object.entries(value))
+                    yield kv;
+                return;
+            }
+            for (const [key, dsc] of Object.entries(Object.getOwnPropertyDescriptors(value))) {
+                if (isFunc && !Func.isPropAllowed(key))
+                    continue;
+                if ('value' in dsc)
+                    yield [key, dsc.value, dsc];
+                else if (dsc.get)
+                    yield [key, dsc.get.call(value), dsc];
+            }
+        }
+        /**
+         * @summary Iterate `[key, value]` entries of an `Array`/`Set`/`Map` node
+         */
+        function* richIterate(value) {
+            if (value instanceof Map) {
+                for (const [k, v] of value)
+                    yield [k, v];
+                return;
+            }
+            let i = 0;
+            for (const v of value)
+                yield [i++, v];
+        }
+        function resolveOption(opt, node, key) {
+            return ('function' === typeof opt ? opt(node, key) : opt);
+        }
+        //#endregion
+        //#region WalkDef
+        function WalkDef(options) {
+            function walkDef(nodeType, defaults) {
+                const p = nodeTypePrefix(nodeType);
+                if (options && (`${p}Inc` in options || `${p}Exc` in options))
+                    return {};
+                return defaults;
+            }
+            for (const nt of LowLevel.TypeGroups)
+                Object.defineProperty(walkDef, nt.toCapitalized(), {
+                    value(defaults) {
+                        return walkDef(nt, defaults);
+                    }
+                });
+            return walkDef;
+        }
+        //#endregion
+        //#region Is
+        const deepOpsIs = (() => {
+            const walkFieldNames = LowLevel.TypeGroups.flatMap((nt) => {
+                const p = `walk${nt.toCapitalized()}`;
+                return [`${p}Inc`, `${p}Exc`];
+            });
+            function isObj(candidate) {
+                return candidate != null
+                    && 'object' === typeof candidate;
+            }
+            function isOptBool(v) {
+                return v === undefined || 'boolean' === typeof v;
+            }
+            function isOptBoolOrFunc(v) {
+                return isOptBool || 'function' === typeof v;
+            }
+            function isCommonOptions(candidate) {
+                if (!isObj(candidate))
+                    return false;
+                if (isOptBool(candidate.ownProps))
+                    return true;
+                for (const f of walkFieldNames)
+                    if (f in candidate && candidate[f] !== undefined)
+                        return true;
+                return false;
+            }
+            function isCopyOpsOptions(candidate) {
+                if (!isObj(candidate))
+                    return false;
+                return isOptBool(candidate.copyFuncs);
+            }
+            function isMergeOptions(candidate) {
+                if (!isObj(candidate))
+                    return false;
+                const obj = candidate;
+                return !isCopyOpsOptions(candidate)
+                    || isOptBoolOrFunc(obj.onlyExists)
+                    || isOptBoolOrFunc(obj.isUniqueArrItems)
+                    || isOptBoolOrFunc(obj.nullAsDelete);
+            }
+            return {
+                options: {
+                    common: isCommonOptions,
+                    clone: isCopyOpsOptions,
+                    merge: isMergeOptions
+                }
+            };
+        })();
+        //#endregion
+        //#region deepFreeze
+        function deepFreeze(obj, options) {
+            const WD = WalkDef(options);
+            const _options = {
+                ...options,
+                symbol: symbolFreeze,
+                ...WD.Scalar({ walkScalarExc: false }),
+                ...WD.Atomic({ walkAtomicExc: false }),
+                ...WD.Plain({ walkPlainInc: true }),
+                ...WD.Rich({ walkRichInc: true }),
+                ...WD.Func({
+                    walkFuncInc: {
+                        class: false,
+                        generator: false
+                    }
+                })
+            };
+            const seen = new Set();
+            const hasCustomFreeze = Symbol.Has(symbolFreeze);
+            function walk(value) {
+                const nt = nodeTypeOf(value);
+                const isContainer = 'plain' === nt || 'rich' === nt || 'func' === nt;
+                if (isContainer && seen.has(value))
+                    return value;
+                if (isContainer && hasCustomFreeze(value)) {
+                    seen.add(value);
+                    value[symbolFreeze]();
+                    return value;
+                }
+                const rule = resolveWalkRule(_options, nt, value);
+                if (!rule.walk)
+                    return undefined;
+                if (isContainer)
+                    seen.add(value);
+                if (rule.custom) {
+                    rule.custom(value);
+                    return value;
+                }
+                if ('plain' === nt || 'func' === nt)
+                    for (const [, child] of plainEntries(value, _options.ownProps, 'func' === nt))
+                        walk(child);
+                else if ('rich' === nt) {
+                    const v = value;
+                    if (Array.isArray(v) || v instanceof Set || v instanceof Map)
+                        for (const [, child] of richIterate(v))
+                            walk(child);
+                    else
+                        for (const [, child] of plainEntries(v, _options.ownProps, false))
+                            walk(child);
+                }
+                if (isContainer)
+                    Object.freeze(value);
+                return value;
+            }
+            return walk(obj);
+        }
+        deepFreeze.symbol = symbolFreeze;
+        //#endregion
+        //#region deepClone
+        const deepCloneRich = AllowsClassMap(Array, Set, Map);
+        const SKIP = Symbol('deep-clone-skip');
+        function deepClone(obj, options) {
+            const WD = WalkDef(options);
+            const _options = {
+                ...options,
+                symbol: symbolClone,
+                parentFirst: true,
+                ...WD.Scalar({ walkScalarInc: true }),
+                ...WD.Atomic({ walkAtomicInc: true }),
+                ...WD.Plain({ walkPlainInc: true }),
+                ...WD.Rich({ walkRichExc: deepCloneRich }),
+                ...WD.Func({
+                    walkFuncInc: {
+                        class: false,
+                        generator: false
+                    }
+                })
+            };
+            const hasCustomClone = Symbol.Has(symbolClone);
+            const cloned = new Map();
+            function clone(value) {
+                const nt = nodeTypeOf(value);
+                const isContainer = 'plain' === nt || 'rich' === nt || 'func' === nt;
+                if (isContainer && cloned.has(value))
+                    return cloned.get(value);
+                if (isContainer && hasCustomClone(value)) {
+                    const r = value[symbolClone]();
+                    cloned.set(value, r);
+                    return r;
+                }
+                const rule = resolveWalkRule(_options, nt, value);
+                if (!rule.walk)
+                    return SKIP;
+                if (rule.custom) {
+                    const r = rule.custom(value);
+                    if (isContainer)
+                        cloned.set(value, r);
+                    return r;
+                }
+                switch (nt) {
+                    case 'scalar':
+                        return value;
+                    case 'atomic':
+                        return AtomicObjects.descriptor(value).clone(value);
+                    case 'plain': {
+                        const r = {};
+                        cloned.set(value, r);
+                        const entries = plainEntries(value, _options.ownProps, false);
+                        for (const [key, child, dsc] of entries) {
+                            const c = clone(child);
+                            if (c === SKIP)
+                                continue;
+                            if (dsc)
+                                Object.defineProperty(r, key, { ...dsc, value: c });
+                            else
+                                r[key] = c;
+                        }
+                        return r;
+                    }
+                    case 'rich': {
+                        const v = value;
+                        if (Array.isArray(v)) {
+                            const r = [];
+                            cloned.set(value, r);
+                            for (const item of v) {
+                                const c = clone(item);
+                                if (c !== SKIP)
+                                    r.push(c);
+                            }
+                            return r;
+                        }
+                        if (v instanceof Set) {
+                            const r = new Set();
+                            cloned.set(value, r);
+                            for (const item of v) {
+                                const c = clone(item);
+                                if (c !== SKIP)
+                                    r.add(c);
+                            }
+                            return r;
+                        }
+                        if (v instanceof Map) {
+                            const r = new Map();
+                            cloned.set(value, r);
+                            for (const [k, item] of v) {
+                                const c = clone(item);
+                                if (c !== SKIP)
+                                    r.set(clone(k), c);
+                            }
+                            return r;
+                        }
+                        throw Error(`Cannot clone rich object "${v?.constructor?.name}"`);
+                    }
+                    case 'func': {
+                        const fn = value;
+                        if (_options.copyFuncs) {
+                            cloned.set(value, fn);
+                            return fn;
+                        }
+                        const wrapper = 'async' === Func.determineType(fn)
+                            ? async (...params) => fn(...params)
+                            : (...params) => fn(...params);
+                        cloned.set(value, wrapper);
+                        return wrapper;
+                    }
+                }
+            }
+            const r = clone(obj);
+            return (r === SKIP ? undefined : r);
+        }
+        deepClone.symbol = symbolClone;
+        //#endregion
+        //#region deepMerge
+        function deepMerge(target, ...params) {
+            const { onlyExists, nullAsDelete, isUniqueArrItems, concatArrays, ...options } = params.pop();
+            if (params.length <= 0)
+                return target;
+            const WD = WalkDef(options);
+            const _options = {
+                ...options,
+                symbol: symbolMerge,
+                ...WD.Scalar({ walkScalarInc: true }),
+                ...WD.Atomic({ walkAtomicInc: true }),
+                ...WD.Plain({ walkPlainInc: true }),
+                ...WD.Rich({ walkRichExc: deepCloneRich }),
+                ...WD.Func({
+                    walkFuncInc: {
+                        class: false,
+                        generator: false
+                    }
+                })
+            };
+            const hasCustomMerge = Symbol.Has(symbolMerge);
+            function mergeValue(t, s, ownKey) {
+                if (hasCustomMerge(t))
+                    return t[symbolMerge](s);
+                const nt = nodeTypeOf(t);
+                const ns = nodeTypeOf(s);
+                if (nt !== ns || 'scalar' === nt || 'atomic' === nt)
+                    return deepClone(s, options);
+                if ('plain' === nt || 'func' === nt) {
+                    const entries = plainEntries(s, options.ownProps, 'func' === nt);
+                    for (const [key, sChild] of entries) {
+                        if (!resolveWalkRule(_options, nodeTypeOf(sChild), sChild).walk)
+                            continue;
+                        if (resolveOption(nullAsDelete, sChild, key) && null === sChild) {
+                            delete t[key];
+                            continue;
+                        }
+                        if (resolveOption(onlyExists, sChild, key) && !(key in t))
+                            continue;
+                        t[key] = mergeValue(t[key], sChild, key);
+                    }
+                    return t;
+                }
+                const tv = t;
+                const sv = s;
+                if (Array.isArray(tv)) {
+                    const arr = tv;
+                    const src = sv;
+                    if (resolveOption(concatArrays, arr, ownKey))
+                        for (const sChild of src)
+                            arr.push(deepClone(sChild, options));
+                    else
+                        for (let i = 0; i < src.length; i++) {
+                            const sChild = src[i];
+                            if (!resolveWalkRule(_options, nodeTypeOf(sChild), sChild).walk)
+                                continue;
+                            if (resolveOption(nullAsDelete, sChild, i) && null === sChild) {
+                                if (i < arr.length)
+                                    arr.splice(i, 1);
+                                continue;
+                            }
+                            if (i >= arr.length) {
+                                if (!resolveOption(onlyExists, sChild, i))
+                                    arr.push(deepClone(sChild, options));
+                            }
+                            else
+                                arr[i] = mergeValue(arr[i], sChild, i);
+                        }
+                    if (resolveOption(isUniqueArrItems, arr, ownKey))
+                        arr.splice(0, arr.length, ...new Set(arr));
+                    return arr;
+                }
+                if (tv instanceof Set) {
+                    for (const sChild of sv) {
+                        if (resolveOption(onlyExists, sChild, ownKey) && !tv.has(sChild))
+                            continue;
+                        tv.add('scalar' === nodeTypeOf(sChild) ? sChild : deepClone(sChild, options));
+                    }
+                    return tv;
+                }
+                if (tv instanceof Map) {
+                    for (const [mapKey, sChild] of sv) {
+                        const k = mapKey;
+                        if (resolveOption(nullAsDelete, sChild, k) && null === sChild) {
+                            tv.delete(mapKey);
+                            continue;
+                        }
+                        if (resolveOption(onlyExists, sChild, k) && !tv.has(mapKey))
+                            continue;
+                        tv.set(mapKey, tv.has(mapKey) ? mergeValue(tv.get(mapKey), sChild, k) : deepClone(sChild, options));
+                    }
+                    return tv;
+                }
+                throw Error(`Cannot merge rich object "${tv?.constructor?.name}"`);
+            }
+            let result = deepClone(target, options);
+            for (const source of params)
+                result = mergeValue(result, source);
+            return result;
+        }
+        deepMerge.symbol = symbolMerge;
+        //#endregion
+        return {
+            NodeTypes: LowLevel.TypeGroups,
+            is: deepOpsIs,
+            freeze: deepFreeze,
+            clone: deepClone,
+            merge: deepMerge
+        };
+    });
 })(AVStantso$1 || (AVStantso$1 = {}));
 
 var Func = AVStantso.Func;
 var X = AVStantso.X;
 var Generic = AVStantso.Generic;
+var DeepOps = AVStantso.DeepOps;
 
+exports.DeepOps = DeepOps;
 exports.Func = Func;
 exports.Generic = Generic;
 exports.X = X;