@rainbow-o23/n1 1.0.48 → 1.0.50

package/index.cjs

@@ -11,26 +11,18 @@ var RelativeTime = require('dayjs/plugin/relativeTime.js');
 var UTC = require('dayjs/plugin/utc.js');
 var WeekOfYear = require('dayjs/plugin/weekOfYear.js');
 var nanoid = require('nanoid');
-var math = require('mathjs');
+var Decimal = require('decimal.js');
+var mathjs$1 = require('mathjs');
 
-function _interopNamespaceDefault(e) {
-	var n = Object.create(null);
-	if (e) {
-		Object.keys(e).forEach(function (k) {
-			if (k !== 'default') {
-				var d = Object.getOwnPropertyDescriptor(e, k);
-				Object.defineProperty(n, k, d.get ? d : {
-					enumerable: true,
-					get: function () { return e[k]; }
-				});
-			}
-		});
-	}
-	n.default = e;
-	return Object.freeze(n);
-}
-
-var math__namespace = /*#__PURE__*/_interopNamespaceDefault(math);
+dayjs.extend(WeekOfYear);
+dayjs.extend(QuarterOfYear);
+dayjs.extend(Duration);
+dayjs.extend(IsToday);
+dayjs.extend(RelativeTime);
+dayjs.extend(ArraySupport);
+dayjs.extend(ObjectSupport);
+dayjs.extend(CustomParseFormat);
+dayjs.extend(UTC);
 
 const ERR_PIPELINE_NOT_FOUND = 'O01-00001';
 const ERR_TRIM_NON_STRING = 'O01-00002';
@@ -410,28 +402,563 @@ const createConfig = (logger) => {
     return new Config(logger ?? createLogger());
 };
 
-dayjs.extend(WeekOfYear);
-dayjs.extend(QuarterOfYear);
-dayjs.extend(Duration);
-dayjs.extend(IsToday);
-dayjs.extend(RelativeTime);
-dayjs.extend(ArraySupport);
-dayjs.extend(ObjectSupport);
-dayjs.extend(CustomParseFormat);
-dayjs.extend(UTC);
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const StaticImplements = () => {
+    return (_constructor) => {
+    };
+};
+
+const OBJECT_PROTOTYPE = Object.prototype;
+
+const isLength = (value) => {
+    return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= Number.MAX_SAFE_INTEGER;
+};
+const isArrayLike = (value) => {
+    return value != null && typeof value !== 'function' && isLength(value.length);
+};
+const isPrototype = (value) => {
+    const Ctor = value && value.constructor;
+    const proto = (typeof Ctor === 'function' && Ctor.prototype) || OBJECT_PROTOTYPE;
+    return value === proto;
+};
+const isNull = (value) => {
+    return value == null
+        ? { test: true, value: value }
+        : { test: false, value };
+};
+const isNotNull = (value) => ({ test: !isNull(value).test, value });
+const isEmpty = (value) => {
+    if (value == null) {
+        return { test: true, value: value };
+    }
+    let length = null;
+    if (isArrayLike(value) && (Array.isArray(value) || typeof value === 'string')) {
+        length = value.length;
+    }
+    else if (value instanceof Map) {
+        length = value.size;
+    }
+    else if (value instanceof Set) {
+        length = value.size;
+    }
+    else if (isPrototype(value)) {
+        length = Object.keys(value).length;
+    }
+    return { test: length === 0, value };
+};
+const isNotEmpty = (value) => ({ test: !isEmpty(value).test, value });
+const isBlank = (value) => {
+    switch (true) {
+        case (value == null):
+            return { test: true, value: value };
+        case (typeof value === 'string' && value.trim().length === 0):
+            return { test: true, value: value };
+        default:
+            return { test: false, value };
+    }
+};
+const isNotBlank = (value) => ({ test: !isBlank(value).test, value });
+
+const regexp = (regexp) => {
+    return (value) => {
+        if (value == null) {
+            return { test: false, value };
+        }
+        const type = typeof value;
+        if (['string', 'number', 'bigint'].includes(type)) {
+            return { test: regexp.test(value), value };
+        }
+        return { test: false, value };
+    };
+};
 
+exports.Rounding = void 0;
+(function (Rounding) {
+    Rounding["ROUND_UP"] = "up";
+    Rounding["ROUND_DOWN"] = "down";
+    Rounding["ROUND_CEIL"] = "ceil";
+    Rounding["ROUND_FLOOR"] = "floor";
+    Rounding["ROUND_HALF_UP"] = "half-up";
+    Rounding["ROUND_HALF_DOWN"] = "half-down";
+    Rounding["ROUND_HALF_EVEN"] = "half-even";
+    Rounding["ROUND_HALF_CEIL"] = "half-ceil";
+    Rounding["ROUND_HALF_FLOOR"] = "half-floor";
+})(exports.Rounding || (exports.Rounding = {}));
+const ToDecimalJsRounding = {
+    [exports.Rounding.ROUND_UP]: Decimal.ROUND_UP,
+    [exports.Rounding.ROUND_DOWN]: Decimal.ROUND_DOWN,
+    [exports.Rounding.ROUND_CEIL]: Decimal.ROUND_CEIL,
+    [exports.Rounding.ROUND_FLOOR]: Decimal.ROUND_FLOOR,
+    [exports.Rounding.ROUND_HALF_UP]: Decimal.ROUND_HALF_UP,
+    [exports.Rounding.ROUND_HALF_DOWN]: Decimal.ROUND_HALF_DOWN,
+    [exports.Rounding.ROUND_HALF_EVEN]: Decimal.ROUND_HALF_EVEN,
+    [exports.Rounding.ROUND_HALF_CEIL]: Decimal.ROUND_HALF_CEIL,
+    [exports.Rounding.ROUND_HALF_FLOOR]: Decimal.ROUND_HALF_FLOOR
+};
+const toDecimal = (value) => {
+    if (value == null) {
+        return { test: false, value };
+    }
+    else if (value instanceof Decimal) {
+        return { test: true, value };
+    }
+    else if (['string', 'number'].includes(typeof value)) {
+        try {
+            return { test: true, value: new Decimal(value) };
+        }
+        catch {
+            return { test: false, value };
+        }
+    }
+    else {
+        return { test: false, value };
+    }
+};
+const toNumber = (value) => {
+    const { test, value: parsed } = toDecimal(value);
+    if (!test) {
+        return { test: false, value };
+    }
+    return { test: true, value: parsed.toNumber() };
+};
+const toFixed = (fractionDigits, rounding = exports.Rounding.ROUND_HALF_UP) => {
+    return (value) => {
+        const { test, value: parsed } = toDecimal(value);
+        if (!test) {
+            return { test: false, value };
+        }
+        return { test: true, value: parsed.toFixed(fractionDigits, ToDecimalJsRounding[rounding]) };
+    };
+};
+const baseRound = (rounding = exports.Rounding.ROUND_HALF_UP) => {
+    return (fractionDigits) => {
+        return (value) => {
+            const { test, value: parsed } = toDecimal(value);
+            if (!test) {
+                return { test: false, value };
+            }
+            return { test: true, value: parsed.toDecimalPlaces(fractionDigits, ToDecimalJsRounding[rounding]) };
+        };
+    };
+};
+const roundUp = baseRound(exports.Rounding.ROUND_HALF_UP);
+const roundDown = baseRound(exports.Rounding.ROUND_HALF_DOWN);
+const floor = baseRound(exports.Rounding.ROUND_FLOOR);
+const ceil = baseRound(exports.Rounding.ROUND_CEIL);
+const roundBy = (fractionDigits, rounding = exports.Rounding.ROUND_HALF_UP) => {
+    return baseRound(rounding)(fractionDigits);
+};
+
+const isDecimal = (value) => {
+    const { test, value: decimal } = toDecimal(value);
+    return { test, value: test ? decimal : value };
+};
+const isInteger = (value) => {
+    const { test, value: decimal } = toDecimal(value);
+    return (test && decimal.isInteger()) ? { test: true, value: decimal } : { test: false, value };
+};
+const isInRange = (options) => {
+    const { min, max, interval = 'closed' } = options;
+    return (value) => {
+        const { test, value: decimal } = toDecimal(value);
+        if (!test) {
+            return { test: false, value };
+        }
+        let pass = false;
+        switch (interval) {
+            case 'open':
+            case 'o':
+                pass = (min == null || decimal.gt(min)) && (max == null || decimal.lt(max));
+                break;
+            case 'left-open':
+            case 'lo':
+                pass = (min == null || decimal.gt(min)) && (max == null || decimal.lte(max));
+                break;
+            case 'right-open':
+            case 'ro':
+                pass = (min == null || decimal.gte(min)) && (max == null || decimal.lt(max));
+                break;
+            case 'closed':
+            case 'c':
+            default:
+                pass = (min == null || decimal.gte(min)) && (max == null || decimal.lte(max));
+                break;
+        }
+        return pass ? { test: true, value: decimal } : { test: false, value };
+    };
+};
+const isPositive = isInRange({ min: 0, interval: 'left-open' });
+const isNotPositive = isInRange({ max: 0 });
+const isNegative = isInRange({ max: 0, interval: 'right-open' });
+const isNotNegative = isInRange({ min: 0 });
+const isZero = (value) => {
+    const { test, value: decimal } = toDecimal(value);
+    return (test && decimal.isZero()) ? { test: true, value: decimal } : { test: false, value };
+};
+const isNotZero = (value) => {
+    const { test, value: decimal } = toDecimal(value);
+    return (test && !decimal.isZero()) ? { test: true, value: decimal } : { test: false, value };
+};
+const isGreaterThan = (compare) => {
+    return isInRange({ min: compare, interval: 'left-open' });
+};
+const isGreaterThanOrEqual = (compare) => {
+    return isInRange({ min: compare });
+};
+const isLessThan = (compare) => {
+    return isInRange({ max: compare, interval: 'right-open' });
+};
+const isLessThanOrEqual = (compare) => {
+    return isInRange({ max: compare });
+};
+
+const testers = {
+    isNull: { type: 'func', func: isNull },
+    isNotNull: { type: 'func', func: isNotNull },
+    isEmpty: { type: 'func', func: isEmpty },
+    isNotEmpty: { type: 'func', func: isNotEmpty },
+    isBlank: { type: 'func', func: isBlank },
+    isNotBlank: { type: 'func', func: isNotBlank },
+    regexp: { type: 'param', func: regexp },
+    regex: { type: 'param', func: regexp },
+    matches: { type: 'param', func: regexp },
+    isNumber: { type: 'func', func: isDecimal },
+    isDecimal: { type: 'func', func: isDecimal },
+    isInteger: { type: 'func', func: isInteger },
+    isInt: { type: 'func', func: isInteger },
+    isPositive: { type: 'func', func: isPositive },
+    isNotPositive: { type: 'func', func: isNotPositive },
+    isNegative: { type: 'func', func: isNegative },
+    isNotNegative: { type: 'func', func: isNotNegative },
+    isZero: { type: 'func', func: isZero },
+    isNotZero: { type: 'func', func: isNotZero },
+    isGreaterThan: { type: 'param', func: isGreaterThan },
+    gt: { type: 'param', func: isGreaterThan },
+    isGreaterThanOrEqual: {
+        type: 'param', func: isGreaterThanOrEqual
+    },
+    gte: { type: 'param', func: isGreaterThanOrEqual },
+    isLessThan: { type: 'param', func: isLessThan },
+    lt: { type: 'param', func: isLessThan },
+    isLessThanOrEqual: {
+        type: 'param', func: isLessThanOrEqual
+    },
+    lte: { type: 'param', func: isLessThanOrEqual },
+    isInRange: { type: 'param', func: isInRange },
+    within: { type: 'param', func: isInRange }
+};
+const AllTesters = testers;
+
+const trim = (value) => {
+    if (value == null) {
+        return { test: true, value };
+    }
+    else if (typeof value === 'string') {
+        return { test: true, value: value.trim() };
+    }
+    else {
+        return { test: true, value };
+    }
+};
+const pad = (options) => {
+    const { length, char = ' ', direction = 'right' } = options;
+    return (value) => {
+        if (value == null) {
+            return { test: false, value };
+        }
+        const type = typeof value;
+        if (['string', 'number', 'bigint', 'boolean'].includes(type)) {
+            const stringified = `${value}`;
+            const len = stringified.length;
+            if (len >= length) {
+                return { test: true, value: stringified };
+            }
+            return {
+                test: true,
+                value: direction === 'left' ? stringified.padStart(length, char) : stringified.padEnd(length, char)
+            };
+        }
+        else {
+            return { test: false, value };
+        }
+    };
+};
+const padStart = (options) => pad({ ...options, direction: 'left' });
+const padEnd = (options) => pad({ ...options, direction: 'right' });
+
+const transformers = {
+    trim: { type: 'func', func: trim },
+    pad: { type: 'param', func: pad },
+    padStart: { type: 'param', func: padStart },
+    padLeft: { type: 'param', func: padStart },
+    lpad: { type: 'param', func: padStart },
+    padEnd: { type: 'param', func: padEnd },
+    padRight: { type: 'param', func: padEnd },
+    rpad: { type: 'param', func: padEnd },
+    toDecimal: { type: 'func', func: toDecimal },
+    toNumber: { type: 'func', func: toNumber },
+    toFixed0: { type: 'func', func: toFixed(0) },
+    toFixed1: { type: 'func', func: toFixed(1) },
+    toFixed2: { type: 'func', func: toFixed(2) },
+    toFixed3: { type: 'func', func: toFixed(3) },
+    toFixed4: { type: 'func', func: toFixed(4) },
+    toFixed5: { type: 'func', func: toFixed(5) },
+    toFixed6: { type: 'func', func: toFixed(6) },
+    toFixed: { type: 'param', func: toFixed },
+    round: { type: 'param', func: roundUp },
+    roundUp: { type: 'param', func: roundUp },
+    roundDown: { type: 'param', func: roundDown },
+    floor: { type: 'param', func: floor },
+    ceil: { type: 'param', func: ceil },
+    roundBy: { type: 'param', func: roundBy }
+};
+const AllTransformers = transformers;
+
+var ValueOperatorBootstrap_1;
+const applyOperator = (operator, base) => {
+    if (base.$allowNoParamFuncCall) {
+        base.$allowNoParamFuncCall = false;
+        return operator;
+    }
+    else {
+        throw new Error(`Function call is not allowed from: ${operator}.`);
+    }
+};
+const NOT_FOUND = Symbol('not found');
+const findValueAction = (actions) => {
+    return (operator, base, prop) => {
+        const tester = actions[prop];
+        if (tester == null) {
+            return NOT_FOUND;
+        }
+        base.$allowUseDefault = true;
+        if (base.$actions == null) {
+            base.$actions = [];
+        }
+        if (tester.type === 'func') {
+            base.$actions.push(tester.func);
+            base.$allowNoParamFuncCall = true;
+            return operator;
+        }
+        else if (tester.type === 'param') {
+            return (...args) => {
+                base.$actions.push(tester.func(...args));
+                return operator;
+            };
+        }
+        else {
+            throw new Error(`Unknown tester type: ${tester}.`);
+        }
+    };
+};
+const findTester = findValueAction(AllTesters);
+const findTransformer = findValueAction(AllTransformers);
+const findUseDefault = (operator, base, prop) => {
+    if (!base.$allowUseDefault || !['orUseDefault', 'useDefault', 'withDefault', 'orElse', 'else'].includes(prop)) {
+        return NOT_FOUND;
+    }
+    if ((base.$actions == null || base.$actions.length === 0)) {
+        return (void 0);
+    }
+    base.$allowMoreAction = false;
+    base.$allowUseDefault = false;
+    return (defaultValue) => {
+        base.$defaultUsed = true;
+        base.$defaultValue = defaultValue;
+        return operator;
+    };
+};
+const createValueRetrieveFunc = (base) => {
+    return () => {
+        const tested = { test: true, value: base.$value };
+        for (const action of (base.$actions ?? [])) {
+            const result = action(tested.value);
+            if (!result.test) {
+                tested.test = false;
+                tested.value = base.$value;
+                break;
+            }
+            else {
+                tested.value = result.value;
+            }
+        }
+        if (tested.test) ;
+        else if (base.$defaultUsed) {
+            tested.test = true;
+            tested.value = base.$defaultValue;
+        }
+        else {
+            tested.value = base.$value;
+        }
+        return tested;
+    };
+};
+const findValue = (_operator, base, prop) => {
+    if (prop !== 'value') {
+        return NOT_FOUND;
+    }
+    if ((base.$actions == null || base.$actions.length === 0)) {
+        return (void 0);
+    }
+    return () => createValueRetrieveFunc(base)().value;
+};
+const findSuccessOrFailureCallback = (_operator, base, prop) => {
+    if (prop !== 'success' && prop !== 'failure') {
+        return NOT_FOUND;
+    }
+    if ((base.$actions == null || base.$actions.length === 0)) {
+        return (void 0);
+    }
+    switch (prop) {
+        case 'success':
+            return (callback) => {
+                const tested = createValueRetrieveFunc(base)();
+                if (tested.test) {
+                    callback(tested.value);
+                }
+                return {
+                    failure: (callback) => {
+                        if (!tested.test) {
+                            callback(tested.value);
+                        }
+                    }
+                };
+            };
+        case 'failure':
+            return (callback) => {
+                const tested = createValueRetrieveFunc(base)();
+                if (!tested.test) {
+                    callback(tested.value);
+                }
+                return {
+                    success: (callback) => {
+                        if (tested.test) {
+                            callback(tested.value);
+                        }
+                    }
+                };
+            };
+        default:
+            throw new Error(`Unknown callback type: ${prop}.`);
+    }
+};
+const findOK = (operator, base, prop) => {
+    if (prop !== 'ok') {
+        return NOT_FOUND;
+    }
+    if ((base.$actions == null || base.$actions.length === 0)) {
+        return (void 0);
+    }
+    return () => createValueRetrieveFunc(base)().test;
+};
+const findPromise = (_operator, base, prop) => {
+    if (prop !== 'promise') {
+        return NOT_FOUND;
+    }
+    if ((base.$actions == null || base.$actions.length === 0)) {
+        return (void 0);
+    }
+    return async () => {
+        const tested = createValueRetrieveFunc(base)();
+        if (tested.test) {
+            return Promise.resolve(tested.value);
+        }
+        else {
+            return Promise.reject(tested.value);
+        }
+    };
+};
+const getFromOperator = (operator, base, prop) => {
+    base.$allowNoParamFuncCall = false;
+    const finds = [
+        findTester, findTransformer, findUseDefault,
+        findValue, findSuccessOrFailureCallback, findOK, findPromise
+    ];
+    for (const find of finds) {
+        const result = find(operator, base, prop);
+        if (result !== NOT_FOUND) {
+            return result;
+        }
+    }
+    return (void 0);
+};
+const createOperator = (base) => {
+    const operatorBase = () => {
+    };
+    operatorBase.$base = base;
+    const operator = new Proxy(operatorBase, {
+        apply(base, _thisArg, _argArray) {
+            return applyOperator(operator, base.$base);
+        },
+        get(base, p, _receiver) {
+            return getFromOperator(operator, base.$base, p);
+        }
+    });
+    return operator;
+};
+let ValueOperatorBootstrap = ValueOperatorBootstrap_1 = class ValueOperatorBootstrap {
+    constructor() {
+    }
+    static of(value) {
+        return createOperator({
+            $value: value,
+            $allowMoreAction: true, $allowUseDefault: false, $defaultUsed: false,
+            $allowNoParamFuncCall: false
+        });
+    }
+    static from(value) {
+        return ValueOperatorBootstrap_1.of(value);
+    }
+    static with(value) {
+        return ValueOperatorBootstrap_1.of(value);
+    }
+};
+ValueOperatorBootstrap = ValueOperatorBootstrap_1 = __decorate([
+    StaticImplements()
+], ValueOperatorBootstrap);
+const ValueOperator = ValueOperatorBootstrap;
+
+var StepHelpersUtils_1;
 const PIPELINE_STEP_FILE_SYMBOL = Symbol();
 const PIPELINE_STEP_RETURN_NULL = Symbol();
-class StepHelpersUtils {
+exports.StepHelpersUtils = class StepHelpersUtils {
+    static { StepHelpersUtils_1 = this; }
     static asciiNanoId = nanoid.customAlphabet('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_', 32);
-    static OBJECT_PROTOTYPE = Object.prototype;
     constructor() {
     }
     static $nano(size) {
         return nanoid.nanoid(size);
     }
     static $ascii(size) {
-        return StepHelpersUtils.asciiNanoId(size);
+        return StepHelpersUtils_1.asciiNanoId(size);
     }
     static createCatchableError = (options) => {
         throw new CatchableError(options.code, options.reason);
@@ -452,14 +979,14 @@ class StepHelpersUtils {
         return e != null && e instanceof UncatchableError;
     };
     static $errors = {
-        catchable: StepHelpersUtils.createCatchableError,
-        isCatchable: StepHelpersUtils.isCatchableError,
-        exposed: StepHelpersUtils.createExposedUncatchableError,
-        isExposed: StepHelpersUtils.isExposedUncatchableError,
-        uncatchable: StepHelpersUtils.createUncatchableError,
-        isUncatchable: StepHelpersUtils.isUncatchableError
+        catchable: StepHelpersUtils_1.createCatchableError,
+        isCatchable: StepHelpersUtils_1.isCatchableError,
+        exposed: StepHelpersUtils_1.createExposedUncatchableError,
+        isExposed: StepHelpersUtils_1.isExposedUncatchableError,
+        uncatchable: StepHelpersUtils_1.createUncatchableError,
+        isUncatchable: StepHelpersUtils_1.isUncatchableError
     };
-    static createFile(options) {
+    static $file(options) {
         return {
             $file: PIPELINE_STEP_FILE_SYMBOL,
             name: options.name, type: options.type,
@@ -471,47 +998,26 @@ class StepHelpersUtils {
     }
     static isPrototype(value) {
         const Ctor = value && value.constructor;
-        const proto = (typeof Ctor === 'function' && Ctor.prototype) || StepHelpersUtils.OBJECT_PROTOTYPE;
+        const proto = (typeof Ctor === 'function' && Ctor.prototype) || OBJECT_PROTOTYPE;
         return value === proto;
     }
     static isLength(value) {
-        return typeof value === 'number' && value > -1 && value % 1 === 0 && value <= Number.MAX_SAFE_INTEGER;
+        return isLength(value);
     }
     static isArrayLike(value) {
-        return value != null && typeof value !== 'function' && StepHelpersUtils.isLength(value.length);
+        return isArrayLike(value);
     }
     static isEmpty(value) {
-        if (value == null) {
-            return true;
-        }
-        if (StepHelpersUtils.isArrayLike(value) && (Array.isArray(value) || typeof value === 'string')) {
-            return value.length === 0;
-        }
-        else if (value instanceof Map) {
-            return value.size === 0;
-        }
-        else if (value instanceof Set) {
-            return value.size === 0;
-        }
-        else if (StepHelpersUtils.isPrototype(value)) {
-            return Object.keys(value).length === 0;
-        }
-        return false;
+        return isEmpty(value).test;
     }
     static isNotEmpty(value) {
-        return !StepHelpersUtils.isEmpty(value);
+        return isNotEmpty(value).test;
     }
     static isBlank(value) {
-        if (value == null) {
-            return true;
-        }
-        if (typeof value !== 'string') {
-            return false;
-        }
-        return value.trim().length === 0;
+        return isBlank(value).test;
     }
     static isNotBlank(value) {
-        return !StepHelpersUtils.isBlank(value);
+        return isNotBlank(value).test;
     }
     static trim(value) {
         if (value == null) {
@@ -522,7 +1028,17 @@ class StepHelpersUtils {
         }
         throw new UncatchableError(ERR_TRIM_NON_STRING, `Cannot apply trim to non-string object[type=${typeof value}, value=${value}].`);
     }
-}
+    static touch(value) {
+        return ValueOperator.from(value);
+    }
+    static noop() {
+    }
+    static async asyncNoop() {
+    }
+};
+exports.StepHelpersUtils = StepHelpersUtils_1 = __decorate([
+    StaticImplements()
+], exports.StepHelpersUtils);
 
 class PerformanceExecution {
     options;
@@ -636,22 +1152,31 @@ const RegisteredHelpers = { helpers: {} };
 const registerToStepHelpers = (helpers) => {
     RegisteredHelpers.helpers = helpers ?? {};
 };
+const mathjs = mathjs$1.create(mathjs$1.all, { number: 'BigNumber', precision: 32 });
 const createStepHelpers = (config, logger) => {
-    return {
+    const helpers = {
         ...RegisteredHelpers.helpers,
         $config: config, $logger: logger,
         $date: new PipelineStepDateHelper(config),
-        $math: math__namespace,
-        $nano: StepHelpersUtils.$nano, $ascii: StepHelpersUtils.$ascii,
-        $error: StepHelpersUtils.createExposedUncatchableError,
+        $math: mathjs,
+        $decimal: (value) => new Decimal(value),
+        $nano: exports.StepHelpersUtils.$nano, $ascii: exports.StepHelpersUtils.$ascii,
+        $error: exports.StepHelpersUtils.createExposedUncatchableError,
         $errorCodes: ErrorCodes,
-        $errors: StepHelpersUtils.$errors,
-        $file: StepHelpersUtils.createFile,
-        $clearContextData: StepHelpersUtils.$clearContextData,
-        isEmpty: StepHelpersUtils.isEmpty, isNotEmpty: StepHelpersUtils.isNotEmpty,
-        isBlank: StepHelpersUtils.isBlank, isNotBlank: StepHelpersUtils.isNotBlank,
-        trim: StepHelpersUtils.trim
+        $errors: exports.StepHelpersUtils.$errors,
+        $file: exports.StepHelpersUtils.$file,
+        $clearContextData: exports.StepHelpersUtils.$clearContextData,
+        isEmpty: exports.StepHelpersUtils.isEmpty, isNotEmpty: exports.StepHelpersUtils.isNotEmpty,
+        isBlank: exports.StepHelpersUtils.isBlank, isNotBlank: exports.StepHelpersUtils.isNotBlank,
+        trim: exports.StepHelpersUtils.trim,
+        touch: exports.StepHelpersUtils.touch,
+        noop: exports.StepHelpersUtils.noop, asyncNoop: exports.StepHelpersUtils.asyncNoop
     };
+    return new Proxy(helpers, {
+        set(_target, _p, _value, _receiver) {
+            return false;
+        }
+    });
 };
 
 class AbstractPipelineStep extends AbstractPipelineExecution {
@@ -792,6 +1317,8 @@ exports.AbstractPipeline = AbstractPipeline;
 exports.AbstractPipelineExecution = AbstractPipelineExecution;
 exports.AbstractPipelineStep = AbstractPipelineStep;
 exports.AbstractStaticPipeline = AbstractStaticPipeline;
+exports.AllTesters = AllTesters;
+exports.AllTransformers = AllTransformers;
 exports.CatchableError = CatchableError;
 exports.Config = Config;
 exports.ConsoleLogger = ConsoleLogger;
@@ -806,15 +1333,51 @@ exports.ErrorCodes = ErrorCodes;
 exports.ExposedUncatchableError = ExposedUncatchableError;
 exports.LoggerPerformanceSaver = LoggerPerformanceSaver;
 exports.LoggerUtils = LoggerUtils;
+exports.OBJECT_PROTOTYPE = OBJECT_PROTOTYPE;
 exports.PIPELINE_STEP_FILE_SYMBOL = PIPELINE_STEP_FILE_SYMBOL;
 exports.PIPELINE_STEP_RETURN_NULL = PIPELINE_STEP_RETURN_NULL;
 exports.PerformanceExecution = PerformanceExecution;
 exports.PipelineRepository = PipelineRepository;
 exports.PipelineStepDateHelper = PipelineStepDateHelper;
-exports.StepHelpersUtils = StepHelpersUtils;
 exports.UncatchableError = UncatchableError;
+exports.ValueOperator = ValueOperator;
+exports.ceil = ceil;
 exports.createConfig = createConfig;
 exports.createLogger = createLogger;
 exports.createStepHelpers = createStepHelpers;
+exports.floor = floor;
+exports.isArrayLike = isArrayLike;
+exports.isBlank = isBlank;
+exports.isDecimal = isDecimal;
+exports.isEmpty = isEmpty;
+exports.isGreaterThan = isGreaterThan;
+exports.isGreaterThanOrEqual = isGreaterThanOrEqual;
+exports.isInRange = isInRange;
+exports.isInteger = isInteger;
+exports.isLength = isLength;
+exports.isLessThan = isLessThan;
+exports.isLessThanOrEqual = isLessThanOrEqual;
+exports.isNegative = isNegative;
+exports.isNotBlank = isNotBlank;
+exports.isNotEmpty = isNotEmpty;
+exports.isNotNegative = isNotNegative;
+exports.isNotNull = isNotNull;
+exports.isNotPositive = isNotPositive;
+exports.isNotZero = isNotZero;
+exports.isNull = isNull;
+exports.isPositive = isPositive;
+exports.isPrototype = isPrototype;
+exports.isZero = isZero;
+exports.pad = pad;
+exports.padEnd = padEnd;
+exports.padStart = padStart;
+exports.regexp = regexp;
 exports.registerToStepHelpers = registerToStepHelpers;
+exports.roundBy = roundBy;
+exports.roundDown = roundDown;
+exports.roundUp = roundUp;
 exports.saveLoggerPerformance = saveLoggerPerformance;
+exports.toDecimal = toDecimal;
+exports.toFixed = toFixed;
+exports.toNumber = toNumber;
+exports.trim = trim;