@pioneer-platform/helpers 4.0.3 → 4.0.5

package/lib/modules/bigIntArithmetics.js

@@ -11,222 +11,440 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BigIntArithmetics = exports.formatBigIntToSafeValue = void 0;
 var types_1 = require("@coinmasters/types");
+var TAG = " | BigIntArithmetics | ";
 var DEFAULT_DECIMAL = 8;
 var bigintPow = function (base, exponent) {
-    var result = BigInt(1);
-    while (exponent > 0) {
-        if (exponent % 2 === 1) {
-            result *= base;
+    var tag = TAG + " | bigintPow | ";
+    try {
+        var result = BigInt(1);
+        while (exponent > 0) {
+            if (exponent % 2 === 1) {
+                result *= base;
+            }
+            base *= base;
+            exponent = Math.floor(exponent / 2);
         }
-        base *= base;
-        exponent = Math.floor(exponent / 2);
+        return result;
+    }
+    catch (error) {
+        console.error(tag + 'Error in bigintPow:', error);
+        return BigInt(1);
     }
-    return result;
 };
 var toMultiplier = function (decimal) {
-    console.log('toMultiplier input decimal:', decimal);
+    var tag = TAG + " | toMultiplier | ";
+    console.log(tag + 'input decimal:', decimal);
     try {
         var result = bigintPow(BigInt(10), decimal);
-        console.log('toMultiplier result:', result);
+        console.log(tag + 'result:', result);
         return result;
     }
     catch (error) {
-        console.error('Error in toMultiplier:', error);
+        console.error(tag + 'Error in toMultiplier:', error);
         return BigInt(10);
     }
 };
-var decimalFromMultiplier = function (multiplier) { return Math.log10(Number(multiplier)); };
+var decimalFromMultiplier = function (multiplier) {
+    var tag = TAG + " | decimalFromMultiplier | ";
+    try {
+        return Math.log10(Number(multiplier));
+    }
+    catch (error) {
+        console.error(tag + 'Error in decimalFromMultiplier:', error);
+        return 0;
+    }
+};
 function formatBigIntToSafeValue(_a) {
     var value = _a.value, _b = _a.bigIntDecimal, bigIntDecimal = _b === void 0 ? DEFAULT_DECIMAL : _b, _c = _a.decimal, decimal = _c === void 0 ? DEFAULT_DECIMAL : _c;
-    var isNegative = value < BigInt(0);
-    var valueString = value.toString().substring(isNegative ? 1 : 0);
-    var padLength = decimal - (valueString.length - 1);
-    if (padLength > 0) {
-        valueString = '0'.repeat(padLength) + valueString;
-    }
-    var decimalIndex = valueString.length - decimal;
-    var decimalString = valueString.slice(-decimal);
-    if (parseInt(decimalString[bigIntDecimal]) >= 5) {
-        decimalString = "".concat(decimalString.substring(0, bigIntDecimal - 1)).concat((parseInt(decimalString[bigIntDecimal - 1]) + 1).toString());
+    var tag = TAG + " | formatBigIntToSafeValue | ";
+    try {
+        console.log(tag, 'value:', value, 'bigIntDecimal:', bigIntDecimal, 'decimal:', decimal);
+        // Check if the value is negative and throw an error if true
+        if (value < BigInt(0)) {
+            throw new Error(tag + 'Negative value is not allowed');
+        }
+        // Convert bigint to string and handle potential negative sign
+        var valueString = value.toString();
+        // Calculate padding length required to match the specified decimal places
+        var padLength = decimal - (valueString.length - 1);
+        // Pad the value string with leading zeros if necessary
+        if (padLength > 0) {
+            valueString = '0'.repeat(padLength) + valueString;
+        }
+        // Determine the position of the decimal point
+        var decimalIndex = valueString.length - decimal;
+        // Extract the decimal part of the value
+        var decimalString = valueString.slice(-decimal);
+        // Trim the decimal string to match the specified bigIntDecimal length
+        if (decimalString.length > bigIntDecimal) {
+            decimalString = decimalString.substring(0, bigIntDecimal);
+        }
+        // Construct the final string with the integer and decimal parts
+        var formattedValue = "".concat(valueString.slice(0, decimalIndex), ".").concat(decimalString).replace(/\.?0*$/, '');
+        // Log the formatted value for debugging
+        console.log(tag + 'Formatted Value:', formattedValue);
+        return formattedValue;
     }
-    else {
-        decimalString = decimalString.substring(0, bigIntDecimal);
+    catch (error) {
+        // Log any errors encountered during the process
+        console.error(tag + 'Error in formatBigIntToSafeValue:', error);
+        return '';
     }
-    return "".concat(isNegative ? '-' : '').concat(valueString.slice(0, decimalIndex), ".").concat(decimalString).replace(/\.?0*$/, '');
 }
 exports.formatBigIntToSafeValue = formatBigIntToSafeValue;
+// export function formatBigIntToSafeValue({
+//                                           value,
+//                                           bigIntDecimal = DEFAULT_DECIMAL,
+//                                           decimal = DEFAULT_DECIMAL,
+//                                         }: {
+//   value: bigint;
+//   bigIntDecimal?: number;
+//   decimal?: number;
+// }): string {
+//   let tag = TAG + " | formatBigIntToSafeValue | ";
+//   try {
+//     const isNegative = value < BigInt(0);
+//     let valueString = value.toString().substring(isNegative ? 1 : 0);
+//
+//     const padLength = decimal - (valueString.length - 1);
+//
+//     if (padLength > 0) {
+//       valueString = '0'.repeat(padLength) + valueString;
+//     }
+//
+//     const decimalIndex = valueString.length - decimal;
+//     let decimalString = valueString.slice(-decimal);
+//
+//     if (decimalString.length > bigIntDecimal) {
+//       decimalString = decimalString.substring(0, bigIntDecimal);
+//     }
+//
+//     return `${isNegative ? '-' : ''}${valueString.slice(0, decimalIndex)}.${decimalString}`.replace(
+//         /\.?0*$/,
+//         '',
+//     );
+//   } catch (error) {
+//     console.error(tag + 'Error in formatBigIntToSafeValue:', error);
+//     return '';
+//   }
+// }
 var BigIntArithmetics = /** @class */ (function () {
     function BigIntArithmetics(params) {
-        this.decimalMultiplier = bigintPow(BigInt(10), 8);
-        this.bigIntValue = BigInt(0);
-        console.log('Constructor Params:', params);
-        var value = getStringValue(params);
-        console.log('String Value:', value);
-        var isComplex = typeof params === 'object' && params !== null;
-        this.decimal = isComplex ? params.decimal : undefined;
-        console.log('Decimal:', this.decimal);
-        if (isComplex && 'decimalMultiplier' in params) {
-            this.decimalMultiplier = params.decimalMultiplier;
-        }
-        else {
-            var maxDecimals = Math.max(getFloatDecimals(toSafeValue(value)), this.decimal || 0);
-            this.decimalMultiplier = toMultiplier(maxDecimals);
-        }
-        console.log('Decimal Multiplier:', this.decimalMultiplier);
-        this.setValue(value);
-        console.log('BigInt Value:', this.bigIntValue);
+        var tag = TAG + " | constructor | ";
+        try {
+            console.log(tag + 'Constructor Params:', params);
+            var value = getStringValue(params);
+            console.log(tag + 'String Value:', value);
+            var isComplex = typeof params === 'object' && params !== null;
+            this.decimal = isComplex ? params.decimal : undefined;
+            console.log(tag, 'Decimal:', this.decimal);
+            console.log(tag, 'isComplex:', isComplex);
+            if (isComplex) {
+                this.decimalMultiplier = this.decimal;
+            }
+            else {
+                var maxDecimals = Math.max(getFloatDecimals(toSafeValue(value)), this.decimal || 0);
+                this.decimalMultiplier = toMultiplier(maxDecimals);
+            }
+            console.log(tag + 'Decimal Multiplier:', this.decimalMultiplier);
+            this.setValue(value);
+            //@ts-ignore
+            console.log(tag + 'BigInt Value:', this.bigIntValue);
+        }
+        catch (error) {
+            console.error(tag + 'Error in constructor:', error);
+            this.decimalMultiplier = BigInt(1);
+            this.bigIntValue = BigInt(0);
+        }
     }
     BigIntArithmetics.fromBigInt = function (value, decimal) {
-        return new BigIntArithmetics({
-            decimal: decimal,
-            value: formatBigIntToSafeValue({ value: value, bigIntDecimal: decimal, decimal: decimal }),
-        });
+        var tag = TAG + " | fromBigInt | ";
+        try {
+            return new BigIntArithmetics({
+                decimal: decimal,
+                value: formatBigIntToSafeValue({ value: value, bigIntDecimal: decimal, decimal: decimal }),
+            });
+        }
+        catch (error) {
+            console.error(tag + 'Error in fromBigInt:', error);
+            return new BigIntArithmetics(0);
+        }
     };
     BigIntArithmetics.shiftDecimals = function (_a) {
         var value = _a.value, from = _a.from, to = _a.to;
-        return this.fromBigInt((value.getBaseValue('bigint') * toMultiplier(to)) / toMultiplier(from), to);
+        var tag = TAG + " | shiftDecimals | ";
+        try {
+            return this.fromBigInt((value.getBaseValue('bigint') * toMultiplier(to)) / toMultiplier(from), to);
+        }
+        catch (error) {
+            console.error(tag + 'Error in shiftDecimals:', error);
+            return new BigIntArithmetics(0);
+        }
     };
     BigIntArithmetics.prototype.set = function (value) {
-        // @ts-ignore
-        return new BigIntArithmetics({ decimal: this.decimal, value: value });
+        var tag = TAG + " | set | ";
+        try {
+            // @ts-ignore
+            return new BigIntArithmetics({ decimal: this.decimal, value: value });
+        }
+        catch (error) {
+            console.error(tag + 'Error in set:', error);
+            return this;
+        }
     };
     BigIntArithmetics.prototype.add = function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        return this.arithmetics.apply(this, __spreadArray(['add'], args, false));
+        var tag = TAG + " | add | ";
+        try {
+            return this.arithmetics.apply(this, __spreadArray(['add'], args, false));
+        }
+        catch (error) {
+            console.error(tag + 'Error in add:', error);
+            return this;
+        }
     };
     BigIntArithmetics.prototype.sub = function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        return this.arithmetics.apply(this, __spreadArray(['sub'], args, false));
+        var tag = TAG + " | sub | ";
+        try {
+            return this.arithmetics.apply(this, __spreadArray(['sub'], args, false));
+        }
+        catch (error) {
+            console.error(tag + 'Error in sub:', error);
+            return this;
+        }
     };
     BigIntArithmetics.prototype.mul = function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        return this.arithmetics.apply(this, __spreadArray(['mul'], args, false));
+        var tag = TAG + " | mul | ";
+        try {
+            return this.arithmetics.apply(this, __spreadArray(['mul'], args, false));
+        }
+        catch (error) {
+            console.error(tag + 'Error in mul:', error);
+            return this;
+        }
     };
     BigIntArithmetics.prototype.div = function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        return this.arithmetics.apply(this, __spreadArray(['div'], args, false));
+        var tag = TAG + " | div | ";
+        try {
+            return this.arithmetics.apply(this, __spreadArray(['div'], args, false));
+        }
+        catch (error) {
+            console.error(tag + 'Error in div:', error);
+            return this;
+        }
     };
     BigIntArithmetics.prototype.gt = function (value) {
-        return this.comparison('gt', value);
+        var tag = TAG + " | gt | ";
+        try {
+            return this.comparison('gt', value);
+        }
+        catch (error) {
+            console.error(tag + 'Error in gt:', error);
+            return false;
+        }
     };
     BigIntArithmetics.prototype.gte = function (value) {
-        return this.comparison('gte', value);
+        var tag = TAG + " | gte | ";
+        try {
+            return this.comparison('gte', value);
+        }
+        catch (error) {
+            console.error(tag + 'Error in gte:', error);
+            return false;
+        }
     };
     BigIntArithmetics.prototype.lt = function (value) {
-        return this.comparison('lt', value);
+        var tag = TAG + " | lt | ";
+        try {
+            return this.comparison('lt', value);
+        }
+        catch (error) {
+            console.error(tag + 'Error in lt:', error);
+            return false;
+        }
     };
     BigIntArithmetics.prototype.lte = function (value) {
-        return this.comparison('lte', value);
+        var tag = TAG + " | lte | ";
+        try {
+            return this.comparison('lte', value);
+        }
+        catch (error) {
+            console.error(tag + 'Error in lte:', error);
+            return false;
+        }
     };
     BigIntArithmetics.prototype.eqValue = function (value) {
-        return this.comparison('eqValue', value);
+        var tag = TAG + " | eqValue | ";
+        try {
+            return this.comparison('eqValue', value);
+        }
+        catch (error) {
+            console.error(tag + 'Error in eqValue:', error);
+            return false;
+        }
     };
-    // @ts-ignore
+    //@ts-ignore
     BigIntArithmetics.prototype.getValue = function (type) {
-        var value = formatBigIntToSafeValue({
-            value: this.bigIntValue,
-            bigIntDecimal: this.decimal || decimalFromMultiplier(this.decimalMultiplier),
-        });
-        switch (type) {
-            case 'number':
-                return Number(value);
-            case 'string':
-                return value;
-            case 'bigint':
-                return ((this.bigIntValue * bigintPow(BigInt(10), this.decimal || 8)) /
-                    this.decimalMultiplier);
+        var tag = TAG + " | getValue | ";
+        try {
+            console.log(tag, 'getValue type:', type);
+            console.log(tag, 'decimalMultiplier: ', this.decimalMultiplier);
+            var value = formatBigIntToSafeValue({
+                value: this.bigIntValue,
+                bigIntDecimal: this.decimal || decimalFromMultiplier(this.decimalMultiplier),
+                decimal: this.decimalMultiplier,
+            });
+            console.log(tag, 'value:', value);
+            switch (type) {
+                case 'number':
+                    return Number(value);
+                case 'string':
+                    return value;
+                case 'bigint':
+                    return ((this.bigIntValue * bigintPow(BigInt(10), this.decimal || 8)) /
+                        this.decimalMultiplier);
+            }
+        }
+        catch (error) {
+            console.error(tag + 'Error in getValue:', error);
+            return null;
         }
     };
     // @ts-ignore
     BigIntArithmetics.prototype.getBaseValue = function (type) {
-        var divisor = this.decimalMultiplier / toMultiplier(this.decimal || types_1.BaseDecimal.THOR);
-        var baseValue = this.bigIntValue / divisor;
-        switch (type) {
-            case 'number':
-                return Number(baseValue);
-            case 'string':
-                return baseValue.toString();
-            case 'bigint':
-                return baseValue;
+        var tag = TAG + " | getBaseValue | ";
+        try {
+            var divisor = this.decimalMultiplier / toMultiplier(this.decimal || types_1.BaseDecimal.THOR);
+            var baseValue = this.bigIntValue / divisor;
+            switch (type) {
+                case 'number':
+                    return Number(baseValue);
+                case 'string':
+                    return baseValue.toString();
+                case 'bigint':
+                    return baseValue;
+            }
+        }
+        catch (error) {
+            console.error(tag + 'Error in getBaseValue:', error);
+            return null;
         }
     };
     BigIntArithmetics.prototype.getBigIntValue = function (value, decimal) {
-        if (!decimal && typeof value === 'object' && value !== null) {
-            return value.bigIntValue;
+        var tag = TAG + " | getBigIntValue | ";
+        try {
+            if (!decimal && typeof value === 'object' && value !== null) {
+                return value.bigIntValue;
+            }
+            var stringValue = getStringValue(value);
+            var safeValue = toSafeValue(stringValue);
+            if (safeValue === '0' || safeValue === 'undefined')
+                return BigInt(0);
+            return this.toBigInt(safeValue, decimal);
         }
-        var stringValue = getStringValue(value);
-        var safeValue = toSafeValue(stringValue);
-        if (safeValue === '0' || safeValue === 'undefined')
+        catch (error) {
+            console.error(tag + 'Error in getBigIntValue:', error);
             return BigInt(0);
-        return this.toBigInt(safeValue, decimal);
+        }
     };
     BigIntArithmetics.prototype.toSignificant = function (significantDigits) {
         if (significantDigits === void 0) { significantDigits = 6; }
-        var _a = this.getValue('string').split('.'), int = _a[0], dec = _a[1];
-        var integer = int || '';
-        var decimal = dec || '';
-        var valueLength = parseInt(integer) ? integer.length + decimal.length : decimal.length;
-        if (valueLength <= significantDigits) {
-            return this.getValue('string');
-        }
-        if (integer.length >= significantDigits) {
-            return integer.slice(0, significantDigits).padEnd(integer.length, '0');
-        }
-        if (parseInt(integer)) {
-            return "".concat(integer, ".").concat(decimal.slice(0, significantDigits - integer.length)).padEnd(significantDigits - integer.length, '0');
-        }
-        var trimmedDecimal = parseInt(decimal);
-        var slicedDecimal = "".concat(trimmedDecimal).slice(0, significantDigits);
-        return "0.".concat(slicedDecimal.padStart(decimal.length - "".concat(trimmedDecimal).length + slicedDecimal.length, '0'));
+        var tag = TAG + " | toSignificant | ";
+        try {
+            var _a = this.getValue('string').split('.'), int = _a[0], dec = _a[1];
+            var integer = int || '';
+            var decimal = dec || '';
+            var valueLength = parseInt(integer) ? integer.length + decimal.length : decimal.length;
+            if (valueLength <= significantDigits) {
+                return this.getValue('string');
+            }
+            if (integer.length >= significantDigits) {
+                return integer.slice(0, significantDigits).padEnd(integer.length, '0');
+            }
+            if (parseInt(integer)) {
+                return "".concat(integer, ".").concat(decimal.slice(0, significantDigits - integer.length)).padEnd(significantDigits - integer.length, '0');
+            }
+            var trimmedDecimal = parseInt(decimal);
+            var slicedDecimal = "".concat(trimmedDecimal).slice(0, significantDigits);
+            return "0.".concat(slicedDecimal.padStart(decimal.length - "".concat(trimmedDecimal).length + slicedDecimal.length, '0'));
+        }
+        catch (error) {
+            console.error(tag + 'Error in toSignificant:', error);
+            return '';
+        }
     };
     BigIntArithmetics.prototype.toFixed = function (fixedDigits) {
         if (fixedDigits === void 0) { fixedDigits = 6; }
-        var _a = this.getValue('string').split('.'), int = _a[0], dec = _a[1];
-        var integer = int || '';
-        var decimal = dec || '';
-        if (parseInt(integer)) {
-            return "".concat(integer, ".").concat(decimal.slice(0, fixedDigits)).padEnd(fixedDigits, '0');
-        }
-        var trimmedDecimal = parseInt(decimal);
-        var slicedDecimal = "".concat(trimmedDecimal).slice(0, fixedDigits);
-        return "0.".concat(slicedDecimal.padStart(decimal.length - "".concat(trimmedDecimal).length + slicedDecimal.length, '0'));
+        var tag = TAG + " | toFixed | ";
+        try {
+            var _a = this.getValue('string').split('.'), int = _a[0], dec = _a[1];
+            var integer = int || '';
+            var decimal = dec || '';
+            if (parseInt(integer)) {
+                return "".concat(integer, ".").concat(decimal.slice(0, fixedDigits)).padEnd(fixedDigits, '0');
+            }
+            var trimmedDecimal = parseInt(decimal);
+            var slicedDecimal = "".concat(trimmedDecimal).slice(0, fixedDigits);
+            return "0.".concat(slicedDecimal.padStart(decimal.length - "".concat(trimmedDecimal).length + slicedDecimal.length, '0'));
+        }
+        catch (error) {
+            console.error(tag + 'Error in toFixed:', error);
+            return '';
+        }
     };
     BigIntArithmetics.prototype.toAbbreviation = function (digits) {
         if (digits === void 0) { digits = 2; }
-        var value = this.getValue('number');
-        var abbreviations = ['', 'K', 'M', 'B', 'T', 'Q', 'Qi', 'S'];
-        var tier = Math.floor(Math.log10(Math.abs(value)) / 3);
-        var suffix = abbreviations[tier];
-        if (!suffix)
-            return this.getValue('string');
-        var scale = Math.pow(10, (tier * 3));
-        var scaled = value / scale;
-        return "".concat(scaled.toFixed(digits)).concat(suffix);
+        var tag = TAG + " | toAbbreviation | ";
+        try {
+            var value = this.getValue('number');
+            var abbreviations = ['', 'K', 'M', 'B', 'T', 'Q', 'Qi', 'S'];
+            var tier = Math.floor(Math.log10(Math.abs(value)) / 3);
+            var suffix = abbreviations[tier];
+            if (!suffix)
+                return this.getValue('string');
+            var scale = Math.pow(10, (tier * 3));
+            var scaled = value / scale;
+            return "".concat(scaled.toFixed(digits)).concat(suffix);
+        }
+        catch (error) {
+            console.error(tag + 'Error in toAbbreviation:', error);
+            return '';
+        }
     };
     BigIntArithmetics.prototype.toCurrency = function (currency, _a) {
         if (currency === void 0) { currency = '$'; }
         var _b = _a === void 0 ? {} : _a, _c = _b.currencyPosition, currencyPosition = _c === void 0 ? 'start' : _c, _d = _b.decimal, decimal = _d === void 0 ? 2 : _d, _e = _b.decimalSeparator, decimalSeparator = _e === void 0 ? '.' : _e, _f = _b.thousandSeparator, thousandSeparator = _f === void 0 ? ',' : _f;
-        var value = this.getValue('number');
-        var _g = value.toFixed(6).split('.'), int = _g[0], _h = _g[1], dec = _h === void 0 ? '' : _h;
-        var integer = int.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
-        var parsedValue = !int && !dec
-            ? '0.00'
-            : int === '0'
-                ? "".concat(parseFloat("0.".concat(dec))).replace('.', decimalSeparator)
-                : "".concat(integer).concat(parseInt(dec) ? "".concat(decimalSeparator).concat(dec.slice(0, decimal)) : '');
-        return "".concat(currencyPosition === 'start' ? currency : '').concat(parsedValue).concat(currencyPosition === 'end' ? currency : '');
+        var tag = TAG + " | toCurrency | ";
+        try {
+            var value = this.getValue('number');
+            var _g = value.toFixed(6).split('.'), int = _g[0], _h = _g[1], dec = _h === void 0 ? '' : _h;
+            var integer = int.replace(/\B(?=(\d{3})+(?!\d))/g, thousandSeparator);
+            var parsedValue = !int && !dec
+                ? '0.00'
+                : int === '0'
+                    ? "".concat(parseFloat("0.".concat(dec))).replace('.', decimalSeparator)
+                    : "".concat(integer).concat(parseInt(dec) ? "".concat(decimalSeparator).concat(dec.slice(0, decimal)) : '');
+            return "".concat(currencyPosition === 'start' ? currency : '').concat(parsedValue).concat(currencyPosition === 'end' ? currency : '');
+        }
+        catch (error) {
+            console.error(tag + 'Error in toCurrency:', error);
+            return '';
+        }
     };
     BigIntArithmetics.prototype.arithmetics = function (method) {
         var _this = this;
@@ -234,84 +452,118 @@ var BigIntArithmetics = /** @class */ (function () {
         for (var _i = 1; _i < arguments.length; _i++) {
             args[_i - 1] = arguments[_i];
         }
-        var precisionDecimal = this.retrievePrecisionDecimal.apply(this, __spreadArray([this], args, false));
-        var decimal = Math.max(precisionDecimal, decimalFromMultiplier(this.decimalMultiplier));
-        var precisionDecimalMultiplier = toMultiplier(decimal);
-        var result = args.reduce(function (acc, arg) {
-            var value = _this.getBigIntValue(arg, decimal);
-            switch (method) {
-                case 'add':
-                    return acc + value;
-                case 'sub':
-                    return acc - value;
-                case 'mul':
-                    return (acc * value) / precisionDecimalMultiplier;
-                case 'div': {
-                    if (value === BigInt(0))
-                        throw new RangeError('Division by zero');
-                    return (acc * precisionDecimalMultiplier) / value;
+        var tag = TAG + " | arithmetics | ";
+        try {
+            var precisionDecimal = this.retrievePrecisionDecimal.apply(this, __spreadArray([this], args, false));
+            var decimal_1 = Math.max(precisionDecimal, decimalFromMultiplier(this.decimalMultiplier));
+            var precisionDecimalMultiplier_1 = toMultiplier(decimal_1);
+            var result = args.reduce(function (acc, arg) {
+                var value = _this.getBigIntValue(arg, decimal_1);
+                switch (method) {
+                    case 'add':
+                        return acc + value;
+                    case 'sub':
+                        return acc - value;
+                    case 'mul':
+                        return (acc * value) / precisionDecimalMultiplier_1;
+                    case 'div': {
+                        if (value === BigInt(0))
+                            throw new RangeError('Division by zero');
+                        return (acc * precisionDecimalMultiplier_1) / value;
+                    }
+                    default:
+                        return acc;
                 }
-                default:
-                    return acc;
-            }
-        }, (this.bigIntValue * precisionDecimalMultiplier) / this.decimalMultiplier);
-        var formattedValue = formatBigIntToSafeValue({
-            bigIntDecimal: decimal,
-            decimal: decimal,
-            value: result,
-        });
-        return new BigIntArithmetics({
-            decimalMultiplier: toMultiplier(decimal),
-            decimal: this.decimal,
-            value: formattedValue,
-        });
+            }, (this.bigIntValue * precisionDecimalMultiplier_1) / this.decimalMultiplier);
+            var formattedValue = formatBigIntToSafeValue({
+                bigIntDecimal: decimal_1,
+                decimal: decimal_1,
+                value: result,
+            });
+            return new BigIntArithmetics({
+                decimalMultiplier: toMultiplier(decimal_1),
+                decimal: this.decimal,
+                value: formattedValue,
+            });
+        }
+        catch (error) {
+            console.error(tag + 'Error in arithmetics:', error);
+            return this;
+        }
     };
     BigIntArithmetics.prototype.comparison = function (method) {
         var args = [];
         for (var _i = 1; _i < arguments.length; _i++) {
             args[_i - 1] = arguments[_i];
         }
-        var decimal = this.retrievePrecisionDecimal.apply(this, __spreadArray([this], args, false));
-        var value = this.getBigIntValue(args[0], decimal);
-        var compareToValue = this.getBigIntValue(this, decimal);
-        switch (method) {
-            case 'gt':
-                return compareToValue > value;
-            case 'gte':
-                return compareToValue >= value;
-            case 'lt':
-                return compareToValue < value;
-            case 'lte':
-                return compareToValue <= value;
-            case 'eqValue':
-                return compareToValue === value;
+        var tag = TAG + " | comparison | ";
+        try {
+            var decimal = this.retrievePrecisionDecimal.apply(this, __spreadArray([this], args, false));
+            var value = this.getBigIntValue(args[0], decimal);
+            var compareToValue = this.getBigIntValue(this, decimal);
+            switch (method) {
+                case 'gt':
+                    return compareToValue > value;
+                case 'gte':
+                    return compareToValue >= value;
+                case 'lt':
+                    return compareToValue < value;
+                case 'lte':
+                    return compareToValue <= value;
+                case 'eqValue':
+                    return compareToValue === value;
+            }
+        }
+        catch (error) {
+            console.error(tag + 'Error in comparison:', error);
+            return false;
         }
     };
     BigIntArithmetics.prototype.setValue = function (value) {
-        var safeValue = toSafeValue(value) || '0';
-        this.bigIntValue = this.toBigInt(safeValue);
+        var tag = TAG + " | setValue | ";
+        try {
+            var safeValue = toSafeValue(value) || '0';
+            this.bigIntValue = this.toBigInt(safeValue);
+        }
+        catch (error) {
+            console.error(tag + 'Error in setValue:', error);
+        }
     };
     BigIntArithmetics.prototype.retrievePrecisionDecimal = function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        var decimals = args
-            .map(function (arg) {
-            var isObject = typeof arg === 'object' && arg !== null;
-            var value = isObject
-                ? arg.decimal || decimalFromMultiplier(arg.decimalMultiplier)
-                : getFloatDecimals(toSafeValue(arg));
-            return value;
-        })
-            .filter(Boolean);
-        return Math.max.apply(Math, __spreadArray(__spreadArray([], decimals, false), [DEFAULT_DECIMAL], false));
+        var tag = TAG + " | retrievePrecisionDecimal | ";
+        try {
+            var decimals = args
+                .map(function (arg) {
+                var isObject = typeof arg === 'object' && arg !== null;
+                var value = isObject
+                    ? arg.decimal || decimalFromMultiplier(arg.decimalMultiplier)
+                    : getFloatDecimals(toSafeValue(arg));
+                return value;
+            })
+                .filter(Boolean);
+            return Math.max.apply(Math, __spreadArray(__spreadArray([], decimals, false), [DEFAULT_DECIMAL], false));
+        }
+        catch (error) {
+            console.error(tag + 'Error in retrievePrecisionDecimal:', error);
+            return DEFAULT_DECIMAL;
+        }
     };
     BigIntArithmetics.prototype.toBigInt = function (value, decimal) {
-        var multiplier = decimal ? toMultiplier(decimal) : this.decimalMultiplier;
-        var padDecimal = decimalFromMultiplier(multiplier);
-        var _a = value.split('.'), _b = _a[0], integerPart = _b === void 0 ? '' : _b, _c = _a[1], decimalPart = _c === void 0 ? '' : _c;
-        return BigInt("".concat(integerPart).concat(decimalPart.padEnd(padDecimal, '0')));
+        var tag = TAG + " | toBigInt | ";
+        try {
+            var multiplier = decimal ? toMultiplier(decimal) : this.decimalMultiplier;
+            var padDecimal = decimalFromMultiplier(multiplier);
+            var _a = value.split('.'), _b = _a[0], integerPart = _b === void 0 ? '' : _b, _c = _a[1], decimalPart = _c === void 0 ? '' : _c;
+            return BigInt("".concat(integerPart).concat(decimalPart.padEnd(padDecimal, '0')));
+        }
+        catch (error) {
+            console.error(tag + 'Error in toBigInt:', error);
+            return BigInt(0);
+        }
     };
     return BigIntArithmetics;
 }());
@@ -321,24 +573,45 @@ var numberFormatter = Intl.NumberFormat('fullwide', {
     maximumFractionDigits: 20,
 });
 function toSafeValue(value) {
-    var parsedValue = typeof value === 'number' ? numberFormatter.format(value) : getStringValue(value);
-    var splitValue = "".concat(parsedValue).replace(/,/g, '.').split('.');
-    return splitValue.length > 1
-        ? "".concat(splitValue.slice(0, -1).join(''), ".").concat(splitValue.at(-1))
-        : splitValue[0];
+    var tag = TAG + " | toSafeValue | ";
+    try {
+        var parsedValue = typeof value === 'number' ? numberFormatter.format(value) : getStringValue(value);
+        var splitValue = "".concat(parsedValue).replace(/,/g, '.').split('.');
+        return splitValue.length > 1
+            ? "".concat(splitValue.slice(0, -1).join(''), ".").concat(splitValue.at(-1))
+            : splitValue[0];
+    }
+    catch (error) {
+        console.error(tag + 'Error in toSafeValue:', error);
+        return '0';
+    }
 }
 function getFloatDecimals(value) {
-    var decimals = 0;
-    var parts = value.split('.');
-    if (parts.length > 1 && parts[1].length > 0) {
-        decimals = parts[1].length;
+    var tag = TAG + " | getFloatDecimals | ";
+    try {
+        var decimals = 0;
+        var parts = value.split('.');
+        if (parts.length > 1 && parts[1].length > 0) {
+            decimals = parts[1].length;
+        }
+        return Math.max(decimals, DEFAULT_DECIMAL);
+    }
+    catch (error) {
+        console.error(tag + 'Error in getFloatDecimals:', error);
+        return DEFAULT_DECIMAL;
     }
-    return Math.max(decimals, DEFAULT_DECIMAL);
 }
 function getStringValue(param) {
-    return typeof param === 'object' && param !== null
-        ? 'getValue' in param
-            ? param.getValue('string')
-            : param.value
-        : param;
+    var tag = TAG + " | getStringValue | ";
+    try {
+        return typeof param === 'object' && param !== null
+            ? 'getValue' in param
+                ? param.getValue('string')
+                : param.value
+            : param;
+    }
+    catch (error) {
+        console.error(tag + 'Error in getStringValue:', error);
+        return '';
+    }
 }