Fixed invalid behaviour of extractIntegerAndDecimalParts for negative numbers

src/utils/NumberUtils.ts

@@ -20,7 +20,7 @@ export class NumberUtils {
      * @returns {[number, (number | null)]}
      */
     public static extractIntegerAndDecimalParts (number: number): [number, number | null] {
-        const integerPart: number = Math.floor(number);
+        const integerPart: number = Math.trunc(number);
         const decimalPart: number | null = number !== integerPart
             ? number % 1
             : null;
@@ -74,18 +74,6 @@ export class NumberUtils {
         return number < Number.MIN_SAFE_INTEGER || number > Number.MAX_SAFE_INTEGER;
     }
 
-    /**
-     * @param {number} number
-     * @param {number} delta
-     * @returns {boolean}
-     */
-    public static isUnsafePrecisionNumber (number: number, delta: number): boolean {
-        const x: number = number + delta;
-        const x2: number = x - delta;
-
-        return number !== x2;
-    }
-
     /**
      * Returns all factors of a number
      * Based on https://stackoverflow.com/a/43204663

test/functional-tests/node-transformers/converting-transformers/numbers-to-numerical-expressions-transformer/NumbersToNumericalExpressionsTransformer.spec.ts

@@ -99,6 +99,36 @@ describe('NumbersToNumericalExpressionsTransformer', function () {
                 assert.isTrue(areValidExpressions);
             });
         });
+
+        describe('Variant #3: Number `-1e-100`', () => {
+            const number: number = -1e-100;
+            const samplesCount: number = 15;
+
+            let areValidExpressions: boolean = true;
+
+            before(() => {
+                for (let i = 0; i < samplesCount; i++) {
+                    const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
+                        `${number};`,
+                        {
+                            ...NO_ADDITIONAL_NODES_PRESET,
+                            numbersToExpressions: true
+                        }
+                    ).getObfuscatedCode();
+
+                    const result: number = eval(obfuscatedCode);
+
+                    if (result !== number) {
+                        areValidExpressions = false;
+                        break;
+                    }
+                }
+            });
+
+            it('should correctly transform numbers to expressions', () => {
+                assert.isTrue(areValidExpressions);
+            });
+        });
     });
 
     describe('Variant #3: safe integers', () => {

test/unit-tests/utils/NumberUtils.spec.ts

@@ -167,7 +167,7 @@ describe('NumberUtils', function () {
             });
         });
 
-        describe('Variant #5: number `1e-13`', () => {
+        describe('Variant #6: number `1e-13`', () => {
             const number: number = 1e-13;
             const expectedParts: [number, number | null] = [0, 1e-13];
 
@@ -185,6 +185,25 @@ describe('NumberUtils', function () {
                 assert.equal(number, parts[0] + parts[1]!);
             });
         });
+
+        describe('Variant #7: number `-1e-100`', () => {
+            const number: number = -1e-100;
+            const expectedParts: [number, number | null] = [-0, -1e-100];
+
+            let parts: [number, number | null];
+
+            before(() => {
+                parts = NumberUtils.extractIntegerAndDecimalParts(number);
+            });
+
+            it('should extract integer and decimal parts', () => {
+                assert.deepEqual(parts, expectedParts);
+            });
+
+            it('should return an initial number after sum of extracted parts', () => {
+                assert.equal(number, parts[0] + parts[1]!);
+            });
+        });
     });
 
     describe('isCeil', () => {