javascript-obfuscator · sanex3339 · Feb 25, 2021 · Feb 23, 2021 · Feb 25, 2021
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,5 +1,9 @@
 Change Log
 
+v2.10.4
+---
+* Fixed invalid behaviour of `numbersToExpressions` option for float numbers. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/882
+
 v2.10.3
 ---
 * Fixed `simplify` option regression after `2.10.2`. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/864

diff --git a/dist/index.browser.js b/dist/index.browser.js
diff --git a/dist/index.cli.js b/dist/index.cli.js
diff --git a/dist/index.js b/dist/index.js
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "2.10.3",
+  "version": "2.10.4",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -28,7 +28,7 @@
     "chalk": "4.1.0",
     "chance": "1.1.7",
     "class-validator": "0.13.1",
-    "commander": "7.0.0",
+    "commander": "7.1.0",
     "eslint-scope": "5.1.1",
     "estraverse": "5.2.0",
     "fast-deep-equal": "3.1.3",
@@ -55,24 +55,24 @@
     "@types/js-string-escape": "1.0.0",
     "@types/md5": "2.3.0",
     "@types/mkdirp": "1.0.1",
-    "@types/mocha": "8.2.0",
+    "@types/mocha": "8.2.1",
     "@types/multimatch": "4.0.0",
-    "@types/node": "14.14.27",
+    "@types/node": "14.14.31",
     "@types/rimraf": "3.0.0",
     "@types/sinon": "9.0.10",
     "@types/string-template": "1.0.2",
     "@types/webpack-env": "1.16.0",
-    "@typescript-eslint/eslint-plugin": "4.15.0",
-    "@typescript-eslint/parser": "4.15.0",
+    "@typescript-eslint/eslint-plugin": "4.15.1",
+    "@typescript-eslint/parser": "4.15.1",
     "chai": "4.3.0",
     "chai-exclude": "2.0.2",
     "cross-env": "7.0.3",
     "eslint": "7.20.0",
     "eslint-plugin-import": "2.22.1",
-    "eslint-plugin-jsdoc": "31.6.1",
+    "eslint-plugin-jsdoc": "32.1.0",
     "eslint-plugin-no-null": "1.0.2",
     "eslint-plugin-prefer-arrow": "1.2.3",
-    "eslint-plugin-unicorn": "28.0.0",
+    "eslint-plugin-unicorn": "28.0.2",
     "fork-ts-checker-notifier-webpack-plugin": "3.0.0",
     "fork-ts-checker-webpack-plugin": "6.1.0",
     "mocha": "8.3.0",
@@ -85,7 +85,7 @@
     "ts-loader": "8.0.17",
     "ts-node": "9.1.1",
     "typescript": "4.1.5",
-    "webpack": "5.21.2",
+    "webpack": "5.23.0",
     "webpack-cli": "4.5.0",
     "webpack-node-externals": "2.5.2"
   },

diff --git a/src/analyzers/number-numerical-expression-analyzer/NumberNumericalExpressionAnalyzer.ts b/src/analyzers/number-numerical-expression-analyzer/NumberNumericalExpressionAnalyzer.ts
@@ -19,6 +19,11 @@ export class NumberNumericalExpressionAnalyzer implements INumberNumericalExpres
      */
     public static readonly defaultAdditionalPartsCount: number = 3;
 
+    /**
+     * @type {number}
+     */
+    private static readonly delta: number = 10000;
+
     /**
      * @type {Map<number, number[]>}
      */
@@ -70,8 +75,8 @@ export class NumberNumericalExpressionAnalyzer implements INumberNumericalExpres
 
         const upperNumberLimit: number = Math.min(Math.abs(number * 2), Number.MAX_SAFE_INTEGER);
 
-        const from: number = Math.min(-10000, -upperNumberLimit);
-        const to: number = Math.max(10000, upperNumberLimit);
+        const from: number = Math.min(-NumberNumericalExpressionAnalyzer.delta, -upperNumberLimit);
+        const to: number = Math.max(NumberNumericalExpressionAnalyzer.delta, upperNumberLimit);
 
         let temporarySum = 0;
 

diff --git a/src/node-transformers/converting-transformers/NumberToNumericalExpressionTransformer.ts b/src/node-transformers/converting-transformers/NumberToNumericalExpressionTransformer.ts
@@ -16,6 +16,7 @@ import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
 import { NodeFactory } from '../../node/NodeFactory';
 import { NumberNumericalExpressionAnalyzer } from '../../analyzers/number-numerical-expression-analyzer/NumberNumericalExpressionAnalyzer';
+import { NumberUtils } from '../../utils/NumberUtils';
 import { NumericalExpressionDataToNodeConverter } from '../../node/NumericalExpressionDataToNodeConverter';
 
 /**
@@ -86,23 +87,41 @@ export class NumberToNumericalExpressionTransformer extends AbstractNodeTransfor
             return literalNode;
         }
 
-        const numberNumericalExpressionData: TNumberNumericalExpressionData = this.numberNumericalExpressionAnalyzer.analyze(
-            literalNode.value,
-            NumberNumericalExpressionAnalyzer.defaultAdditionalPartsCount
-        );
-
-        return NumericalExpressionDataToNodeConverter.convert(
-            numberNumericalExpressionData,
-            (number: number, isPositiveNumber: boolean) => {
-                const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
-
-                return isPositiveNumber
-                    ? numberLiteralNode
-                    : NodeFactory.unaryExpressionNode(
-                        '-',
-                        numberLiteralNode
-                    );
-            }
-        );
+        const baseNumber: number = literalNode.value;
+        const [integerPart, decimalPart] = NumberUtils.extractIntegerAndDecimalParts(baseNumber);
+        const integerNumberNumericalExpressionData: TNumberNumericalExpressionData = this.numberNumericalExpressionAnalyzer
+            .analyze(
+                integerPart,
+                NumberNumericalExpressionAnalyzer.defaultAdditionalPartsCount
+            );
+
+        if (decimalPart) {
+            return NumericalExpressionDataToNodeConverter.convertFloatNumberData(
+                integerNumberNumericalExpressionData,
+                decimalPart,
+                this.getNumberNumericalExpressionLiteralNode
+            );
+        } else {
+            return NumericalExpressionDataToNodeConverter.convertIntegerNumberData(
+                integerNumberNumericalExpressionData,
+                this.getNumberNumericalExpressionLiteralNode
+            );
+        }
+    }
+
+    /**
+     * @param {number} number
+     * @param {boolean} isPositiveNumber
+     * @returns {Expression}
+     */
+    private getNumberNumericalExpressionLiteralNode (number: number, isPositiveNumber: boolean): ESTree.Expression {
+        const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
+
+        return isPositiveNumber
+            ? numberLiteralNode
+            : NodeFactory.unaryExpressionNode(
+                '-',
+                numberLiteralNode
+            );
     }
 }
diff --git a/src/node-transformers/string-array-transformers/StringArrayRotateFunctionTransformer.ts b/src/node-transformers/string-array-transformers/StringArrayRotateFunctionTransformer.ts
@@ -225,7 +225,7 @@ export class StringArrayRotateFunctionTransformer extends AbstractNodeTransforme
                 StringArrayRotateFunctionTransformer.comparisonExpressionAdditionalPartsCount
             );
 
-        const comparisonExpressionNode: ESTree.Expression = NumericalExpressionDataToNodeConverter.convert(
+        const comparisonExpressionNode: ESTree.Expression = NumericalExpressionDataToNodeConverter.convertIntegerNumberData(
             comparisonExpressionNumberNumericalExpressionData,
             ((number: number, isPositiveNumber) => {
                 const literalNode: ESTree.Literal = NodeFactory.literalNode(

diff --git a/src/node/NumericalExpressionDataToNodeConverter.ts b/src/node/NumericalExpressionDataToNodeConverter.ts
@@ -15,7 +15,7 @@ export class NumericalExpressionDataToNodeConverter {
      * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
      * @returns {Expression}
      */
-    public static convert (
+    public static convertIntegerNumberData (
         numberNumericalExpressionData: TNumberNumericalExpressionData,
         literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
     ): ESTree.Expression {
@@ -25,6 +25,30 @@ export class NumericalExpressionDataToNodeConverter {
        );
     }
 
+    /**
+     * @param {TNumberNumericalExpressionData} integerNumberNumericalExpressionData
+     * @param {number} decimalPart
+     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
+     * @returns {Expression}
+     */
+    public static convertFloatNumberData (
+        integerNumberNumericalExpressionData: TNumberNumericalExpressionData,
+        decimalPart: number,
+        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
+    ): ESTree.Expression {
+        const integerNumberNumericalExpressionNode: ESTree.Expression = NumericalExpressionDataToNodeConverter
+            .convertNumericalExpressionDataToNode(
+                integerNumberNumericalExpressionData,
+                literalNodeGetter
+            );
+
+        return NodeFactory.binaryExpressionNode(
+            '+',
+            integerNumberNumericalExpressionNode,
+            NodeFactory.literalNode(decimalPart)
+        );
+    }
+
     /**
      * @param {TNumberNumericalExpressionData} numberNumericalExpressionData
      * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter

diff --git a/src/utils/NumberUtils.ts b/src/utils/NumberUtils.ts
@@ -15,6 +15,19 @@ export class NumberUtils {
         return `${Utils.hexadecimalPrefix}${basePart}`;
     }
 
+    /**
+     * @param {number} number
+     * @returns {[number, (number | null)]}
+     */
+    public static extractIntegerAndDecimalParts (number: number): [number, number | null] {
+        const integerPart: number = Math.trunc(number);
+        const decimalPart: number | null = number !== integerPart
+            ? number % 1
+            : null;
+
+        return [integerPart, decimalPart];
+    }
+
     /**
      * @param {number} number
      * @returns {boolean}

diff --git a/test/dev/dev.ts b/test/dev/dev.ts
@@ -7,20 +7,17 @@ import { NO_ADDITIONAL_NODES_PRESET } from '../../src/options/presets/NoCustomNo
 
     let obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
         `
-           function foo () {
-              if (bar) {
-                if (baz) {
-                  const a = aa()
-                }
-              } else {
-                bb()
-              }
-            }
+            const epsilon = 500;
+            const number = 500000.0000001;
+
+            if(epsilon > 0 && number > 500000.0000000 && number < 500000.0000002) {
+                console.log("math works!");
+            };
+
         `,
         {
             ...NO_ADDITIONAL_NODES_PRESET,
-            compact: false,
-            simplify: true
+            numbersToExpressions: true
         }
     ).getObfuscatedCode();
 

diff --git a/...ers-to-numerical-expressions-transformer/NumbersToNumericalExpressionsTransformer.spec.ts b/...ers-to-numerical-expressions-transformer/NumbersToNumericalExpressionsTransformer.spec.ts
@@ -40,32 +40,94 @@ describe('NumbersToNumericalExpressionsTransformer', function () {
     });
 
     describe('Variant #2: float number', () => {
-        const number: number = 50.5;
-        const samplesCount: number = 15;
+        describe('Variant #1: Number `50.5`', () => {
+            const number: number = 50.5;
+            const samplesCount: number = 15;
 
-        let areValidExpressions: boolean = true;
+            let areValidExpressions: boolean = true;
 
-        before(() => {
-            for (let i = 0; i < samplesCount; i++) {
-                const obfuscatedCode: string = JavaScriptObfuscator.obfuscate(
-                    `${number};`,
-                    {
-                        ...NO_ADDITIONAL_NODES_PRESET,
-                        numbersToExpressions: 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;
                     }
-                ).getObfuscatedCode();
+                }
+            });
 
-                const result: number = eval(obfuscatedCode);
+            it('should correctly transform numbers to expressions', () => {
+                assert.isTrue(areValidExpressions);
+            });
+        });
 
-                if (result !== number) {
-                    areValidExpressions = false;
-                    break;
+        describe('Variant #2: Number `1e-13`', () => {
+            const number: number = 1e-13;
+            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);
+            });
         });
 
-        it('should correctly transform numbers to expressions', () => {
-            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);
+            });
         });
     });