@leyyo/common 1.0.13 → 1.2.2

package/dist/to/to.common.js

@@ -1,1079 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToCommon = void 0;
-const leyyo_1 = require("../leyyo");
-const internal_1 = require("../internal");
-const primitive_1 = require("./primitive");
-const real_value_1 = require("./real-value");
-const key_value_1 = require("./key-value");
-const weak_true_1 = require("./weak-true");
-const weak_false_1 = require("./weak-false");
-const list_1 = require("./list");
-// noinspection JSUnusedGlobalSymbols
-class ToCommon {
-    // endregion properties
-    constructor(lyy) {
-        this.lyy = lyy;
-        // region properties
-        this._EMPTY = [null, undefined];
-        this._EXPECTED_ANY = ['string', 'boolean', 'bigint', 'object', 'number', 'array'];
-        this._EXPECTED_ARRAY = ['array', 'Set', 'List'];
-        this._EXPECTED_BOOL = ['boolean', 'string', 'number'];
-        this._EXPECTED_DATE = ['string', 'number', 'date', 'moment'];
-        this._EXPECTED_ENUM = ['string', 'number'];
-        this._EXPECTED_NUMBER = ['string', 'number', 'bigint'];
-        this._EXPECTED_STRING = ['boolean', 'string', 'number'];
-        this._EXPECTED_OBJECT = ['object', 'Map'];
-        this._EXPECTED_FUNCTION = ['function', 'Wrap'];
-    }
-    // region secure
-    $init() {
-        this.lyy.$secure.$lazyRun(() => {
-            const enumMap = {
-                Primitive: primitive_1.PrimitiveItems,
-                RealValue: real_value_1.RealValueItems,
-                KeyValue: key_value_1.KeyValueItems,
-                WeakTrue: weak_true_1.WeakTrueItems,
-                WeakFalse: weak_false_1.WeakFalseItems,
-            };
-            for (const [name, value] of Object.entries(enumMap)) {
-                this.lyy.fqn.register(name, value, 'enum', internal_1.FQN);
-                this.lyy.hook.queueForCallback(leyyo_1.LeyyoHookCommon.enumPendingRegister, value);
-            }
-        }).$lazyRun(() => {
-            this.lyy.fqn.register(null, ToCommon, 'class', internal_1.FQN);
-            this.lyy.fqn.register(null, list_1.List, 'class', internal_1.FQN);
-        });
-    }
-    get $back() {
-        return this;
-    }
-    get $secure() {
-        return this;
-    }
-    $runOpt(opt) {
-        if (typeof opt === 'function') {
-            try {
-                return opt();
-            }
-            catch (e) {
-                const key = `<error>[${Date.now()}]`;
-                return {
-                    [key]: [e.message, e.name],
-                };
-            }
-        }
-        else if (!this._EMPTY.includes(opt) || typeof opt !== 'object' || opt.constructor !== Object) {
-            const key = `<invalid-opt>[${Date.now()}]`;
-            return {
-                [key]: this.lyy.dev.secureJson(opt, true),
-            };
-        }
-        else {
-            return opt;
-        }
-    }
-    $runFn(fn, value, opt) {
-        try {
-            return fn(value());
-        }
-        catch (e) {
-            return this.$errorOrLog(opt, undefined, e);
-        }
-    }
-    $errorOrLog(opt, extra, e) {
-        var _a;
-        const newOpt = (_a = this.$runOpt(opt)) !== null && _a !== void 0 ? _a : {};
-        if (!newOpt.silent) {
-            delete newOpt.silent;
-            if (e instanceof Error) {
-                throw this.lyy.dev.nativeError(e, newOpt, extra);
-            }
-            else {
-                throw this.lyy.dev.invalidError(newOpt, extra);
-            }
-        }
-        else {
-            if (e instanceof Error) {
-                this.lyy.dev.log(e, newOpt, 'warn');
-            }
-            else {
-                this.lyy.dev.log(this.lyy.dev.appendAll(newOpt, extra), 'warn');
-            }
-        }
-        return undefined;
-    }
-    $unexpectedError(value, expected, opt) {
-        return this.$errorOrLog(opt, { expected, type: typeof value, value });
-    }
-    $nullError(expected, opt) {
-        return this.$errorOrLog(opt, { issue: 'null', expected });
-    }
-    $emptyError(kind, opt) {
-        return this.$errorOrLog(opt, { issue: kind + '.size' });
-    }
-    $inEnumMap(value, map) {
-        // regular, in values
-        if (Object.values(map).includes(value)) {
-            return value;
-        }
-        // ir-regular, in keys
-        if (Object.keys(map).includes(value)) {
-            return map[value];
-        }
-        if (typeof value === 'string') {
-            // regular, in lower-case
-            let str = value.toLowerCase();
-            let v = this.$inEnumMap(str, map);
-            if (!this._EMPTY.includes(v)) {
-                return v;
-            }
-            // regular, in upper-case
-            str = str.toUpperCase();
-            v = this.$inEnumMap(str, map);
-            if (!this._EMPTY.includes(v)) {
-                return v;
-            }
-            if (/^[0-9]+$/.test(value)) {
-                try {
-                    return this.$inEnumMap(parseInt(value, 10), map);
-                }
-                catch (e) {
-                }
-            }
-            return undefined;
-        }
-        return undefined;
-    }
-    $inEnumArray(value, arr) {
-        // regular, in values
-        if (arr.includes(value)) {
-            return value;
-        }
-        if (typeof value === 'string') {
-            // regular, in lower-case
-            let str = value.toLowerCase();
-            let v = this.$inEnumArray(str, arr);
-            if (!this._EMPTY.includes(v)) {
-                return v;
-            }
-            // regular, in upper-case
-            str = str.toUpperCase();
-            v = this.$inEnumArray(str, arr);
-            if (!this._EMPTY.includes(v)) {
-                return v;
-            }
-            if (/^[0-9]+$/.test(value)) {
-                try {
-                    return this.$inEnumArray(parseInt(value, 10), arr);
-                }
-                catch (e) {
-                }
-            }
-            return undefined;
-        }
-        return undefined;
-    }
-    // noinspection JSMethodCanBeStatic
-    $inEnumAlteration(value, alt) {
-        // ir-regular, in keys
-        if (Object.keys(alt).includes(value)) {
-            return alt[value];
-        }
-        if (typeof value === 'string') {
-            // regular, in lower-case
-            let str = value.toLowerCase();
-            let v = this.$inEnumAlteration(str, alt);
-            if (!this._EMPTY.includes(v)) {
-                return v;
-            }
-            // regular, in upper-case
-            str = str.toUpperCase();
-            v = this.$inEnumAlteration(str, alt);
-            if (!this._EMPTY.includes(v)) {
-                return v;
-            }
-            if (/^[0-9]+$/.test(value)) {
-                try {
-                    return this.$inEnumAlteration(parseInt(value, 10), alt);
-                }
-                catch (e) {
-                }
-            }
-            return undefined;
-        }
-        return undefined;
-    }
-    $realNumber(value, opt) {
-        if (isNaN(value) || !isFinite(value)) {
-            return this.$errorOrLog(opt, { issue: 'invalid.real.number', value, type: typeof value });
-        }
-        return value;
-    }
-    // endregion secure
-    // region types
-    anyStrict(value, opt) {
-        return this.any(value, opt, true);
-    }
-    any(value, opt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_ANY, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case 'string':
-            case 'boolean':
-            case 'bigint':
-            case 'object':
-                return value;
-            case 'number':
-                return this.$realNumber(value, opt);
-            case 'function':
-                return this.$runFn(v => this.any(v, opt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_ANY, opt);
-    }
-    booleanStrict(value, opt) {
-        return this.boolean(value, opt, true);
-    }
-    boolean(value, opt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_BOOL, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case 'boolean':
-                return value;
-            case 'string':
-                value = value.trim().toLowerCase();
-                if (value === '') {
-                    return undefined;
-                }
-                if (weak_true_1.WeakTrueItems.includes(value)) {
-                    return true;
-                }
-                if (weak_false_1.WeakFalseItems.includes(value)) {
-                    return false;
-                }
-                return this.$errorOrLog(opt, { issue: 'invalid.bool.text', value });
-            case 'number':
-                return value > 0;
-            case 'object':
-                if (Array.isArray(value) && value.length === 1) {
-                    return this.boolean(value[0], opt, notNull);
-                }
-                break;
-            case 'function':
-                return this.$runFn(v => this.boolean(v, opt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_BOOL, opt);
-    }
-    dateStrict(value, opt) {
-        return this.date(value, opt, true);
-    }
-    date(value, opt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_DATE, opt);
-            }
-            return value;
-        }
-        let fn;
-        switch (typeof value) {
-            case 'object':
-                if (value instanceof Date) {
-                    return value;
-                }
-                else if (typeof value['toDate'] === 'function') {
-                    fn = () => value['toDate']();
-                    return this.$runFn(v => this.date(v, opt, notNull), fn, opt);
-                }
-                if (Array.isArray(value)) {
-                    const arr = value;
-                    if (arr.length === 1) {
-                        return this.date(arr[0], opt, notNull);
-                    }
-                    if (arr.length > 1 && arr.length < 8) {
-                        const [year, monthIndex, date, hours, minutes, seconds, ms] = arr;
-                        fn = () => new Date(year, monthIndex, date, hours, minutes, seconds, ms);
-                        return this.$runFn(v => this.date(v, opt, notNull), fn, opt);
-                    }
-                }
-                else if (value.id !== undefined) {
-                    return this.date(value.id, opt, notNull);
-                }
-                break;
-            case 'string':
-                if (value.trim() === '') {
-                    return undefined;
-                }
-                fn = () => new Date(value.trim());
-                return this.$runFn(v => this.date(v, opt, notNull), fn, opt);
-            case 'bigint':
-                fn = () => new Date(value.toString(10));
-                return this.$runFn(v => this.date(v, opt, notNull), fn, opt);
-            case 'number':
-                fn = () => new Date(value);
-                return this.$runFn(v => this.date(v, opt, notNull), fn, opt);
-            case 'function':
-                return this.$runFn(v => this.date(v, opt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_DATE, opt);
-    }
-    enumerationStrict(value, map, opt, alt) {
-        return this.enumeration(value, map, opt, alt, true);
-    }
-    enumeration(value, map, opt, alt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_ENUM, opt);
-            }
-            return value;
-        }
-        if (!this.lyy.is.bareObject(map)) {
-            return this.$errorOrLog(opt, { issue: 'invalid.enum.map', type: typeof map, map });
-        }
-        let v;
-        switch (typeof value) {
-            case 'string':
-                value = value.trim();
-                if (value === '') {
-                    return undefined;
-                }
-                v = this.$inEnumMap(value, map);
-                if (!this._EMPTY.includes(v)) {
-                    return v;
-                }
-                if (this.lyy.is.bareObject(alt)) {
-                    v = this.$inEnumAlteration(value, alt);
-                    if (!this._EMPTY.includes(v)) {
-                        return v;
-                    }
-                }
-                return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
-            case 'number':
-                const num = this.$realNumber(value, opt);
-                if (!this._EMPTY.includes(num)) {
-                    return null;
-                }
-                v = this.$inEnumMap(value, map);
-                if (!this._EMPTY.includes(v)) {
-                    return v;
-                }
-                if (this.lyy.is.bareObject(alt)) {
-                    v = this.$inEnumAlteration(value, alt);
-                    if (!this._EMPTY.includes(v)) {
-                        return v;
-                    }
-                }
-                return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
-            case 'object':
-                if (Array.isArray(value) && value.length === 1) {
-                    return this.enumeration(value[0], map, opt, alt, notNull);
-                }
-                return this.enumeration(value.id, map, opt, alt, notNull);
-            case 'function':
-                return this.$runFn(v => this.enumeration(v, map, opt, alt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
-    }
-    literalStrict(value, items, opt, alt) {
-        return this.literal(value, items, opt, alt, true);
-    }
-    literal(value, items, opt, alt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_ENUM, opt);
-            }
-            return value;
-        }
-        if (!Array.isArray(items)) {
-            return this.$errorOrLog(opt, { issue: 'invalid.enum.literal', type: typeof items, items });
-        }
-        let v;
-        switch (typeof value) {
-            case 'string':
-                value = value.trim();
-                if (value === '') {
-                    return undefined;
-                }
-                v = this.$inEnumArray(value, items);
-                if (!this._EMPTY.includes(v)) {
-                    return v;
-                }
-                if (this.lyy.is.bareObject(alt)) {
-                    v = this.$inEnumAlteration(value, alt);
-                    if (!this._EMPTY.includes(v)) {
-                        return v;
-                    }
-                }
-                return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
-            case 'number':
-                const num = this.$realNumber(value, opt);
-                if (!this._EMPTY.includes(num)) {
-                    return null;
-                }
-                v = this.$inEnumArray(value, items);
-                if (!this._EMPTY.includes(v)) {
-                    return v;
-                }
-                if (this.lyy.is.bareObject(alt)) {
-                    v = this.$inEnumAlteration(value, alt);
-                    if (!this._EMPTY.includes(v)) {
-                        return v;
-                    }
-                }
-                return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
-            case 'object':
-                if (Array.isArray(value) && value.length === 1) {
-                    return this.literal(value[0], items, opt, alt, notNull);
-                }
-                return this.literal(value.id, items, opt, alt, notNull);
-            case 'function':
-                return this.$runFn(v => this.literal(v, items, opt, alt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_ENUM, opt);
-    }
-    floatStrict(value, opt) {
-        return this.float(value, opt, true);
-    }
-    float(value, opt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_NUMBER, opt);
-            }
-            return value;
-        }
-        let fn;
-        switch (typeof value) {
-            case 'string':
-                fn = () => parseFloat(value);
-                return this.$runFn(v => this.float(v, opt, notNull), fn, opt);
-            case 'number':
-                return this.$realNumber(value, opt);
-            case 'bigint':
-                fn = () => Number(value);
-                return this.$runFn(v => this.float(v, opt, notNull), fn, opt);
-            case 'boolean':
-                return value ? 1 : 0;
-            case 'object':
-                if (Array.isArray(value) && value.length === 1) {
-                    return this.float(value[0], opt, notNull);
-                }
-                return this.float(value.id, opt, notNull);
-            case 'function':
-                return this.$runFn(v => this.float(v, opt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_NUMBER, opt);
-    }
-    funcStrict(value, opt) {
-        return this.func(value, opt, true);
-    }
-    func(value, opt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_FUNCTION, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case "function":
-                return value;
-            case 'object':
-                if (this.lyy.wrapper.isFunction(value)) {
-                    return this.lyy.wrapper.asFunction(value);
-                }
-                if (Array.isArray(value) && value.length === 1) {
-                    return this.func(value[0], opt, notNull);
-                }
-                break;
-        }
-        return this.$unexpectedError(value, this._EXPECTED_FUNCTION, opt);
-    }
-    integerStrict(value, opt) {
-        return this.integer(value, opt, true);
-    }
-    integer(value, opt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_NUMBER, opt);
-            }
-            return value;
-        }
-        let fn;
-        switch (typeof value) {
-            case 'string':
-                fn = () => parseInt(value);
-                return this.$runFn(v => this.integer(v, opt, notNull), fn, opt);
-            case 'number':
-                let num = this.$realNumber(value, opt);
-                if (num !== null && !Number.isSafeInteger(num)) {
-                    num = Math.floor(num);
-                }
-                return num;
-            case 'bigint':
-                fn = () => Number(value);
-                return this.$runFn(v => this.integer(v, opt, notNull), fn, opt);
-            case 'boolean':
-                return value ? 1 : 0;
-            case 'object':
-                if (Array.isArray(value) && value.length === 1) {
-                    return this.integer(value[0], opt, notNull);
-                }
-                return this.integer(value.id, opt, notNull);
-            case 'function':
-                return this.$runFn(v => this.integer(v, opt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_NUMBER, opt);
-    }
-    stringStrict(value, opt) {
-        return this.string(value, opt, true);
-    }
-    string(value, opt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_STRING, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case 'string':
-                return value;
-            case 'number':
-                const num = this.$realNumber(value, opt);
-                return this._EMPTY.includes(num) ? num : num.toString(10);
-            case 'bigint':
-                return value.toString();
-            case 'boolean':
-                return value ? 'true' : 'false';
-            case 'object':
-                if (Array.isArray(value) && value.length === 1) {
-                    return this.string(value[0], opt, notNull);
-                }
-                return this.string(value.id, opt, notNull);
-            case 'function':
-                return this.$runFn(v => this.string(v, opt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_STRING, opt);
-    }
-    textStrict(value, opt) {
-        return this.text(value, opt, true);
-    }
-    text(value, opt, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_STRING, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case 'string':
-                const str = value.trim();
-                if (str === '') {
-                    if (notNull) {
-                        this.$nullError(this._EXPECTED_STRING, opt);
-                    }
-                    return undefined;
-                }
-                return str;
-            case 'number':
-                const num = this.$realNumber(value, opt);
-                return this._EMPTY.includes(num) ? num : num.toString(10);
-            case 'bigint':
-                return value.toString();
-            case 'boolean':
-                return value ? 'true' : 'false';
-            case 'object':
-                if (Array.isArray(value) && value.length === 1) {
-                    return this.text(value[0], opt, notNull);
-                }
-                return this.text(value.id, opt, notNull);
-            case 'function':
-                return this.$runFn(v => this.text(v, opt, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_STRING, opt);
-    }
-    // endregion types
-    // region objects
-    arrayStrict(value, opt, itemFn) {
-        return this.array(value, opt, itemFn, true);
-    }
-    arrayStrictNotEmpty(value, opt, itemFn) {
-        const result = this.array(value, opt, itemFn, true);
-        if (result.length < 1) {
-            this.$emptyError('array', opt);
-        }
-        return result;
-    }
-    arrayNotEmpty(value, opt, itemFn) {
-        const result = this.array(value, opt, itemFn, false);
-        if (result && result.length < 1) {
-            this.$emptyError('array', opt);
-        }
-        return result;
-    }
-    array(value, opt, itemFn, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_ARRAY, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case "string":
-            case "boolean":
-            case "number":
-            case "bigint":
-                return this.array([value], opt, itemFn, notNull);
-            case 'object':
-                if (value instanceof Set) {
-                    if (value.size < 1) {
-                        return [];
-                    }
-                    return this.array(Array.from(value.values()), opt, itemFn, notNull);
-                }
-                else if (value instanceof list_1.List) {
-                    if (value.length < 1) {
-                        return [];
-                    }
-                    return this.array([...value], opt, itemFn, notNull);
-                }
-                if (Array.isArray(value)) {
-                    if (typeof itemFn !== "function" || value.length < 1) {
-                        return value;
-                    }
-                    const newOpt = this.$runOpt(opt);
-                    const field = (typeof newOpt.field === 'string') ? newOpt.field : undefined;
-                    const clonedOpt = Object.assign({}, newOpt);
-                    return value.map((v, index) => {
-                        clonedOpt.field = field ? `${field}#${index}` : `#${index}`;
-                        try {
-                            return itemFn(v, index, clonedOpt);
-                        }
-                        catch (e) {
-                            if (newOpt.silent) {
-                                this.lyy.dev.log(e, clonedOpt, 'warn');
-                            }
-                            else {
-                                throw this.lyy.dev.nativeError(e, clonedOpt);
-                            }
-                            return v;
-                        }
-                    });
-                }
-                return this.array([value], opt, itemFn, notNull);
-            case 'function':
-                return this.$runFn(v => this.array(v, opt, itemFn, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_ARRAY, opt);
-    }
-    delimitedStrict(value, opt, itemFn) {
-        return this.delimited(value, opt, itemFn, true);
-    }
-    delimitedStrictNotEmpty(value, opt, itemFn) {
-        const result = this.delimited(value, opt, itemFn, true);
-        if (result.length < 1) {
-            this.$emptyError('array', opt);
-        }
-        return result;
-    }
-    delimitedNotEmpty(value, opt, itemFn) {
-        const result = this.delimited(value, opt, itemFn, false);
-        if (result && result.length < 1) {
-            this.$emptyError('array', opt);
-        }
-        return result;
-    }
-    delimited(value, opt, itemFn, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_ARRAY, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case "string":
-                return this.array(value.split(',').map(v => v.trim()), opt, itemFn, notNull);
-            case "boolean":
-            case "number":
-            case "bigint":
-                return this.array([value], opt, itemFn, notNull);
-            case 'object':
-                return this.array(value, opt, itemFn, notNull);
-            case 'function':
-                return this.$runFn(v => this.delimited(v, opt, itemFn, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_ARRAY, opt);
-    }
-    setStrict(value, opt, itemFn) {
-        return this.set(value, opt, itemFn, true);
-    }
-    setStrictNotEmpty(value, opt, itemFn) {
-        const result = this.set(value, opt, itemFn, true);
-        if (result.size < 1) {
-            this.$emptyError('set', opt);
-        }
-        return result;
-    }
-    setNotEmpty(value, opt, itemFn) {
-        const result = this.set(value, opt, itemFn, false);
-        if (result && result.size < 1) {
-            this.$emptyError('set', opt);
-        }
-        return result;
-    }
-    set(value, opt, itemFn, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_ARRAY, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case "string":
-            case "boolean":
-            case "number":
-            case "bigint":
-                return this.set([value], opt, itemFn, notNull);
-            case 'object':
-                if (value instanceof Set) {
-                    if (typeof itemFn !== "function" || value.size < 1) {
-                        return value;
-                    }
-                    const clonedArr = this.array(Array.from(value.values()), opt, itemFn, notNull);
-                    value.clear();
-                    if (clonedArr) {
-                        clonedArr.forEach(item => value.add(item));
-                    }
-                    return value;
-                }
-                else if (value instanceof list_1.List) {
-                    if (value.length < 1) {
-                        return new Set();
-                    }
-                    if (typeof itemFn !== "function") {
-                        return new Set([...value]);
-                    }
-                    return new Set(this.array([...value], opt, itemFn, notNull));
-                }
-                if (Array.isArray(value)) {
-                    if (value.length < 1) {
-                        return new Set();
-                    }
-                    if (typeof itemFn !== "function") {
-                        return new Set(value);
-                    }
-                    return new Set(this.array(value, opt, itemFn, notNull));
-                }
-                break;
-            case 'function':
-                return this.$runFn(v => this.set(v, opt, itemFn, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_ARRAY, opt);
-    }
-    listStrict(value, opt, itemFn) {
-        return this.list(value, opt, itemFn, true);
-    }
-    listStrictNotEmpty(value, opt, itemFn) {
-        const result = this.list(value, opt, itemFn, true);
-        if (result.length < 1) {
-            this.$emptyError('set', opt);
-        }
-        return result;
-    }
-    listNotEmpty(value, opt, itemFn) {
-        const result = this.list(value, opt, itemFn, false);
-        if (result && result.length < 1) {
-            this.$emptyError('set', opt);
-        }
-        return result;
-    }
-    list(value, opt, itemFn, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_ARRAY, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case "string":
-            case "boolean":
-            case "number":
-            case "bigint":
-                return this.list([value], opt, itemFn, notNull);
-            case 'object':
-                if (value instanceof Set) {
-                    const newList = new list_1.List();
-                    if (value.size < 1) {
-                        return newList;
-                    }
-                    if (typeof itemFn !== "function") {
-                        newList.push(...Array.from(value.values()));
-                        return newList;
-                    }
-                    const clonedArr = this.array(Array.from(value.values()), opt, itemFn, notNull);
-                    if (clonedArr) {
-                        newList.push(...clonedArr);
-                    }
-                    return newList;
-                }
-                else if (value instanceof list_1.List) {
-                    if (typeof itemFn !== "function" || value.length < 1) {
-                        return value;
-                    }
-                    const clonedArr = this.array([...value], opt, itemFn, notNull);
-                    value.clear();
-                    if (clonedArr) {
-                        value.push(...clonedArr);
-                    }
-                    return value;
-                }
-                if (Array.isArray(value)) {
-                    const newList = new list_1.List();
-                    if (value.length < 1) {
-                        return newList;
-                    }
-                    if (typeof itemFn !== "function") {
-                        newList.push(...value);
-                        return newList;
-                    }
-                    const clonedArr = this.array(value, opt, itemFn, notNull);
-                    if (clonedArr) {
-                        newList.push(...clonedArr);
-                    }
-                    return newList;
-                }
-                break;
-            case 'function':
-                return this.$runFn(v => this.list(v, opt, itemFn, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_ARRAY, opt);
-    }
-    objectStrict(value, opt) {
-        return this.object(value, opt, true);
-    }
-    object(value, opt, notNull) {
-        return this.dict(value, opt, undefined, undefined, notNull);
-    }
-    mapStrict(value, opt, valueFn, keyFn) {
-        return this.map(value, opt, valueFn, keyFn, true);
-    }
-    mapStrictNotEmpty(value, opt, valueFn, keyFn) {
-        const result = this.map(value, opt, valueFn, keyFn, true);
-        if (result.size < 1) {
-            this.$emptyError('map', opt);
-        }
-        return result;
-    }
-    mapNotEmpty(value, opt, valueFn, keyFn) {
-        const result = this.map(value, opt, valueFn, keyFn, false);
-        if (result && result.size < 1) {
-            this.$emptyError('map', opt);
-        }
-        return result;
-    }
-    map(value, opt, valueFn, keyFn, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_OBJECT, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case 'object':
-                if (value instanceof Set) {
-                    if (value.size === 1) {
-                        return this.map(Array.from(value.values())[0], opt, valueFn, keyFn, notNull);
-                    }
-                }
-                else if (value instanceof list_1.List) {
-                    if (value.length === 1) {
-                        return this.map(value[0], opt, valueFn, keyFn, notNull);
-                    }
-                }
-                else if (value instanceof Map) {
-                    if (typeof valueFn !== "function" && typeof keyFn !== "function") {
-                        return value;
-                    }
-                    if (value.size < 1) {
-                        return value;
-                    }
-                    const newOpt = this.$runOpt(opt);
-                    const field = (typeof newOpt.field === 'string') ? newOpt.field : undefined;
-                    const clonedOpt = Object.assign({}, newOpt);
-                    const cloned = Object.fromEntries(value.entries());
-                    let index = -1;
-                    value.clear();
-                    for (const [k, v] of Object.entries(cloned)) {
-                        if (typeof k === 'symbol') {
-                            continue;
-                        }
-                        index++;
-                        let newKey = k;
-                        let newValue = v;
-                        if (typeof keyFn === 'function') {
-                            clonedOpt.field = field ? `${field}#${index}` : `#${index}`;
-                            try {
-                                newKey = keyFn(k, index, clonedOpt);
-                            }
-                            catch (e) {
-                                this.$errorOrLog(clonedOpt, undefined, e);
-                            }
-                            if (this._EMPTY.includes(newKey)) {
-                                continue;
-                            }
-                        }
-                        if (typeof valueFn === 'function') {
-                            clonedOpt.field = field ? `${field}.${k}` : k;
-                            try {
-                                newValue = valueFn(v, k, clonedOpt);
-                            }
-                            catch (e) {
-                                this.$errorOrLog(clonedOpt, undefined, e);
-                            }
-                        }
-                        value.set(newKey, newValue);
-                    }
-                    return value;
-                }
-                else if (Array.isArray(value)) {
-                    if (value.length === 1) {
-                        return this.map(value[0], opt, valueFn, keyFn, notNull);
-                    }
-                }
-                else if (this.lyy.is.bareObject(value)) {
-                    const newMap = new Map();
-                    const keys = Object.keys(value);
-                    if (keys.length < 1) {
-                        return newMap;
-                    }
-                    for (const [k, v] of Object.entries(value)) {
-                        newMap.set(k, v);
-                    }
-                    return this.map(newMap, opt, valueFn, keyFn, notNull);
-                }
-                break;
-            case 'function':
-                return this.$runFn(v => this.map(v, opt, valueFn, keyFn, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_OBJECT, opt);
-    }
-    dictStrict(value, opt, valueFn, keyFn) {
-        return this.dict(value, opt, valueFn, keyFn, true);
-    }
-    dictStrictNotEmpty(value, opt, valueFn, keyFn) {
-        const result = this.dict(value, opt, valueFn, keyFn, true);
-        if (Object.keys(result).length < 1) {
-            this.$emptyError('dict', opt);
-        }
-        return result;
-    }
-    dictNotEmpty(value, opt, valueFn, keyFn, notNull) {
-        const result = this.dict(value, opt, valueFn, keyFn, false);
-        if (result && Object.keys(result).length < 1) {
-            this.$emptyError('dict', opt);
-        }
-        return result;
-    }
-    dict(value, opt, valueFn, keyFn, notNull) {
-        if (this._EMPTY.includes(value)) {
-            if (notNull) {
-                this.$nullError(this._EXPECTED_OBJECT, opt);
-            }
-            return value;
-        }
-        switch (typeof value) {
-            case 'object':
-                if (value instanceof Set) {
-                    if (value.size === 1) {
-                        return this.dict(Array.from(value.values())[0], opt, valueFn, keyFn, notNull);
-                    }
-                }
-                else if (value instanceof list_1.List) {
-                    if (value.length === 1) {
-                        return this.dict(value[0], opt, valueFn, keyFn, notNull);
-                    }
-                }
-                else if (value instanceof Map) {
-                    if (value.size < 1) {
-                        return {};
-                    }
-                    return this.dict(Object.fromEntries(value.entries()), opt, valueFn, keyFn, notNull);
-                }
-                else if (Array.isArray(value)) {
-                    if (value.length === 1) {
-                        return this.dict(value[0], opt, valueFn, keyFn, notNull);
-                    }
-                }
-                else if (this.lyy.is.bareObject(value)) {
-                    if (typeof valueFn !== "function" && typeof keyFn !== "function") {
-                        return value;
-                    }
-                    const keys = Object.keys(value);
-                    if (keys.length < 1) {
-                        return value;
-                    }
-                    const newOpt = this.$runOpt(opt);
-                    const field = (typeof newOpt.field === 'string') ? newOpt.field : undefined;
-                    const clonedOpt = Object.assign({}, newOpt);
-                    const cloned = Object.assign({}, value);
-                    keys
-                        .filter(k => typeof k !== 'symbol')
-                        .forEach(k => {
-                        try {
-                            delete value[k];
-                        }
-                        catch (e) {
-                        }
-                    });
-                    let index = -1;
-                    for (const [k, v] of Object.entries(cloned)) {
-                        if (typeof k === 'symbol') {
-                            continue;
-                        }
-                        index++;
-                        let newKey = k;
-                        let newValue = v;
-                        if (typeof keyFn === 'function') {
-                            clonedOpt.field = field ? `${field}#${index}` : `#${index}`;
-                            try {
-                                newKey = keyFn(k, index, clonedOpt);
-                            }
-                            catch (e) {
-                                this.$errorOrLog(clonedOpt, undefined, e);
-                            }
-                            if (this._EMPTY.includes(newKey)) {
-                                continue;
-                            }
-                        }
-                        if (typeof valueFn === 'function') {
-                            clonedOpt.field = field ? `${field}.${k}` : k;
-                            try {
-                                newValue = valueFn(v, k, clonedOpt);
-                            }
-                            catch (e) {
-                                this.$errorOrLog(clonedOpt, undefined, e);
-                            }
-                        }
-                        try {
-                            value[newKey] = newValue;
-                        }
-                        catch (e) {
-                        }
-                    }
-                    return value;
-                }
-                // other objects, don't toch
-                return value;
-            case 'function':
-                return this.$runFn(v => this.dict(v, opt, valueFn, keyFn, notNull), value, opt);
-        }
-        return this.$unexpectedError(value, this._EXPECTED_OBJECT, opt);
-    }
-}
-exports.ToCommon = ToCommon;
-//# sourceMappingURL=to.common.js.map