* Fixed broken `identifierNamesGenerator: 'mangled-shuffled'` after `2.2.0`

CHANGELOG.md

@@ -3,8 +3,8 @@ Change Log
 v2.6.0
 ---
 * Migration to `webpack@5`
-* Optimized performance of `ExpressionStatementsMergeTransformer` when `simplify` option is enabled
-
+* Optimized performance of `ExpressionStatementsMergeTransformer` when `simplify` option is enabled. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/777
+* Fixed broken `identifierNamesGenerator: 'mangled-shuffled'` after `2.2.0`. Fixed https://github.com/javascript-obfuscator/javascript-obfuscator/issues/778
 
 v2.5.0
 ---

src/generators/identifier-names-generators/MangledIdentifierNamesGenerator.ts

@@ -59,86 +59,6 @@ export class MangledIdentifierNamesGenerator extends AbstractIdentifierNamesGene
         super(randomGenerator, options);
     }
 
-    /**
-     * @param {string} nextName
-     * @param {string} prevName
-     * @returns {boolean}
-     */
-    // eslint-disable-next-line complexity
-    public static isIncrementedMangledName (nextName: string, prevName: string): boolean {
-        if (nextName === prevName) {
-            return false;
-        }
-
-        const nextNameLength: number = nextName.length;
-        const prevNameLength: number = prevName.length;
-
-        if (nextNameLength !== prevNameLength) {
-            return nextNameLength > prevNameLength;
-        }
-
-        let isIncrementedPrevCharacter: boolean = false;
-
-        for (let i: number = 0; i < nextNameLength; i++) {
-            const nextNameCharacter: string = nextName[i];
-            const prevNameCharacter: string = prevName[i];
-
-            if (nextNameCharacter === prevNameCharacter) {
-                continue;
-            }
-
-            const isDigitNextNameCharacter: boolean = MangledIdentifierNamesGenerator.isDigitCharacter(nextNameCharacter);
-            const isDigitPrevNameCharacter: boolean = MangledIdentifierNamesGenerator.isDigitCharacter(prevNameCharacter);
-
-            if (
-                isIncrementedPrevCharacter
-                && isDigitNextNameCharacter
-                && !isDigitPrevNameCharacter
-            ) {
-                return true;
-            }
-
-            const isUpperCaseNextNameCharacter: boolean = MangledIdentifierNamesGenerator.isUpperCaseCharacter(nextNameCharacter);
-            const isUpperCasePrevNameCharacter: boolean = MangledIdentifierNamesGenerator.isUpperCaseCharacter(prevNameCharacter);
-
-            if (
-                isUpperCaseNextNameCharacter
-                && !isUpperCasePrevNameCharacter
-            ) {
-                return true;
-            } else if (
-                !isUpperCaseNextNameCharacter
-                && isUpperCasePrevNameCharacter
-            ) {
-                return false;
-            }
-
-            isIncrementedPrevCharacter = nextNameCharacter > prevNameCharacter;
-
-            if (nextNameCharacter < prevNameCharacter) {
-                return false;
-            }
-        }
-
-        return nextName > prevName;
-    }
-
-    /**
-     * @param {string} character
-     * @returns {boolean}
-     */
-    private static isUpperCaseCharacter (string: string): boolean {
-        return /^[A-Z]*$/.test(string);
-    }
-
-    /**
-     * @param {string} character
-     * @returns {boolean}
-     */
-    private static isDigitCharacter (string: string): boolean {
-        return /^[0-9]*$/.test(string);
-    }
-
     /**
      * Generates next name based on a global previous mangled name
      * We can ignore nameLength parameter here, it hasn't sense with this generator
@@ -204,6 +124,43 @@ export class MangledIdentifierNamesGenerator extends AbstractIdentifierNamesGene
         return identifierName;
     }
 
+    /**
+     * @param {string} nextName
+     * @param {string} prevName
+     * @returns {boolean}
+     */
+    // eslint-disable-next-line complexity
+    public isIncrementedMangledName (nextName: string, prevName: string): boolean {
+        if (nextName === prevName) {
+            return false;
+        }
+
+        const nextNameLength: number = nextName.length;
+        const prevNameLength: number = prevName.length;
+
+        if (nextNameLength !== prevNameLength) {
+            return nextNameLength > prevNameLength;
+        }
+
+        const nameSequence: string[] = this.getNameSequence();
+
+        for (let i: number = 0; i < nextNameLength; i++) {
+            const nextNameCharacter: string = nextName[i];
+            const prevNameCharacter: string = prevName[i];
+
+            if (nextNameCharacter === prevNameCharacter) {
+                continue;
+            }
+
+            const indexOfNextNameCharacter: number = nameSequence.indexOf(nextNameCharacter);
+            const indexOfPrevNameCharacter: number = nameSequence.indexOf(prevNameCharacter);
+
+            return indexOfNextNameCharacter > indexOfPrevNameCharacter;
+        }
+
+        throw new Error('Something goes wrong during comparison of mangled names');
+    }
+
     /**
      * @param {string} mangledName
      * @returns {boolean}
@@ -224,7 +181,7 @@ export class MangledIdentifierNamesGenerator extends AbstractIdentifierNamesGene
      * @param {string} name
      */
     protected updatePreviousMangledName (name: string): void {
-        if (!MangledIdentifierNamesGenerator.isIncrementedMangledName(name, this.previousMangledName)) {
+        if (!this.isIncrementedMangledName(name, this.previousMangledName)) {
             return;
         }
 

test/unit-tests/generators/identifier-names-generators/MangledShuffledlIdentifierNamesGenerator.spec.ts

@@ -10,6 +10,7 @@ import { IInversifyContainerFacade } from '../../../../src/interfaces/container/
 import { IdentifierNamesGenerator } from '../../../../src/enums/generators/identifier-names-generators/IdentifierNamesGenerator';
 
 import { InversifyContainerFacade } from '../../../../src/container/InversifyContainerFacade';
+import { MangledShuffledIdentifierNamesGenerator } from '../../../../src/generators/identifier-names-generators/MangledShuffledIdentifierNamesGenerator';
 
 describe('MangledShuffledIdentifierNamesGenerator', () => {
     describe('generateNext', () => {
@@ -112,4 +113,43 @@ describe('MangledShuffledIdentifierNamesGenerator', () => {
             });
         });
     });
+
+    describe('isIncrementedMangledName', function () {
+        this.timeout(60000);
+
+        const samplesCount: number = 1000000;
+        const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
+
+        inversifyContainerFacade.load('', '', {});
+        const identifierNamesGenerator: IIdentifierNamesGenerator = inversifyContainerFacade.getNamed<IIdentifierNamesGenerator>(
+            ServiceIdentifiers.IIdentifierNamesGenerator,
+            IdentifierNamesGenerator.MangledShuffledIdentifierNamesGenerator
+        );
+
+        let isSuccessComparison: boolean = true;
+        let mangledName: string = '';
+        let prevMangledName: string = '9';
+
+        for (let sample = 0; sample <= samplesCount; sample++) {
+            let resultNormal: boolean;
+            let resultReversed: boolean;
+
+            mangledName = identifierNamesGenerator.generateNext();
+            resultNormal = (<MangledShuffledIdentifierNamesGenerator>identifierNamesGenerator)
+                .isIncrementedMangledName(mangledName, prevMangledName);
+            resultReversed = (<MangledShuffledIdentifierNamesGenerator>identifierNamesGenerator)
+                .isIncrementedMangledName(prevMangledName, mangledName);
+
+            if (!resultNormal || resultReversed) {
+                isSuccessComparison = false;
+                break;
+            }
+
+            prevMangledName = mangledName;
+        }
+
+        it('should correctly compare mangled names', () => {
+            assert.isTrue(isSuccessComparison);
+        });
+    });
 });

test/unit-tests/generators/identifier-names-generators/MangledlIdentifierNamesGenerator.spec.ts

@@ -192,8 +192,10 @@ describe('MangledIdentifierNamesGenerator', () => {
             let resultReversed: boolean;
 
             mangledName = identifierNamesGenerator.generateNext();
-            resultNormal = MangledIdentifierNamesGenerator.isIncrementedMangledName(mangledName, prevMangledName);
-            resultReversed = MangledIdentifierNamesGenerator.isIncrementedMangledName(prevMangledName, mangledName);
+            resultNormal = (<MangledIdentifierNamesGenerator>identifierNamesGenerator)
+                .isIncrementedMangledName(mangledName, prevMangledName);
+            resultReversed = (<MangledIdentifierNamesGenerator>identifierNamesGenerator)
+                .isIncrementedMangledName(prevMangledName, mangledName);
 
             if (!resultNormal || resultReversed) {
                 isSuccessComparison = false;