Renamed option mangleProperties -> renameProperties

src/JavaScriptObfuscator.ts

@@ -70,7 +70,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
         NodeTransformer.FunctionControlFlowTransformer,
         NodeTransformer.LabeledStatementTransformer,
         NodeTransformer.LiteralTransformer,
-        NodeTransformer.ManglePropertiesTransformer,
+        NodeTransformer.RenamePropertiesTransformer,
         NodeTransformer.MemberExpressionTransformer,
         NodeTransformer.MetadataTransformer,
         NodeTransformer.MethodDefinitionTransformer,
@@ -209,8 +209,8 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
             astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.ControlFlowFlattening);
         }
 
-        if (this.options.mangleProperties) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.MangleProperties);
+        if (this.options.renameProperties) {
+            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.RenameProperties);
         }
 
         astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Converting);

src/cli/JavaScriptObfuscatorCLI.ts

@@ -238,7 +238,7 @@ export class JavaScriptObfuscatorCLI implements IInitializable {
             )
             .option(
                 '--identifiers-prefix <string>',
-                'Sets prefix for all global identifiers.'
+                'Sets prefix for all global identifiers'
             )
             .option(
                 '--identifiers-dictionary <list> (comma separated, without whitespaces)',
@@ -249,10 +249,6 @@ export class JavaScriptObfuscatorCLI implements IInitializable {
                 '--log <boolean>', 'Enables logging of the information to the console',
                 BooleanSanitizer
             )
-            .option(
-                '--mangle-properties <boolean>', 'UNSAFE: Enables mangling property names',
-                BooleanSanitizer
-            )
             .option(
                 '--reserved-names <list> (comma separated, without whitespaces)',
                 'Disables obfuscation and generation of identifiers, which being matched by passed RegExp patterns (comma separated)',
@@ -264,7 +260,11 @@ export class JavaScriptObfuscatorCLI implements IInitializable {
                 ArraySanitizer
             )
             .option(
-                '--rename-globals <boolean>', 'Allows to enable obfuscation of global variable and function names with declaration.',
+                '--rename-globals <boolean>', 'Allows to enable obfuscation of global variable and function names with declaration',
+                BooleanSanitizer
+            )
+            .option(
+                '--rename-properties <boolean>', 'UNSAFE: Enables rename of property names. This probably WILL break your code',
                 BooleanSanitizer
             )
             .option(

src/container/InversifyContainerFacade.ts

@@ -10,12 +10,12 @@ import { customNodesModule } from './modules/custom-nodes/CustomNodesModule';
 import { finalizingTransformersModule } from './modules/node-transformers/FinalizingTransformersModule';
 import { generatorsModule } from './modules/generators/GeneratorsModule';
 import { initializingTransformersModule } from './modules/node-transformers/InitializingTransformersModule';
-import { manglePropertiesTransformersModule } from './modules/node-transformers/ManglePropertiesTransformersModule';
 import { nodeModule } from './modules/node/NodeModule';
 import { nodeTransformersModule } from './modules/node-transformers/NodeTransformersModule';
 import { obfuscatingTransformersModule } from './modules/node-transformers/ObfuscatingTransformersModule';
 import { optionsModule } from './modules/options/OptionsModule';
 import { preparingTransformersModule } from './modules/node-transformers/PreparingTransformersModule';
+import { renamePropertiesTransformersModule } from './modules/node-transformers/RenamePropertiesTransformersModule';
 import { storagesModule } from './modules/storages/StoragesModule';
 import { utilsModule } from './modules/utils/UtilsModule';
 
@@ -211,12 +211,12 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
         this.container.load(finalizingTransformersModule);
         this.container.load(generatorsModule);
         this.container.load(initializingTransformersModule);
-        this.container.load(manglePropertiesTransformersModule);
         this.container.load(nodeModule);
         this.container.load(nodeTransformersModule);
         this.container.load(obfuscatingTransformersModule);
         this.container.load(optionsModule);
         this.container.load(preparingTransformersModule);
+        this.container.load(renamePropertiesTransformersModule);
         this.container.load(storagesModule);
         this.container.load(utilsModule);
     }

src/container/ServiceIdentifiers.ts

@@ -33,7 +33,6 @@ export enum ServiceIdentifiers {
     IJavaScriptObfuscator = 'IJavaScriptObfuscator',
     ILevelledTopologicalSorter = 'ILevelledTopologicalSorter',
     ILogger = 'ILogger',
-    IManglePropertiesObfuscatingReplacer = 'IManglePropertiesObfuscatingReplacer',
     INodeGuard = 'INodeGuard',
     INodeTransformer = 'INodeTransformer',
     INodeTransformerNamesGroupsBuilder = 'INodeTransformerNamesGroupsBuilder',
@@ -45,6 +44,7 @@ export enum ServiceIdentifiers {
     IPrevailingKindOfVariablesAnalyzer = 'IPrevailingKindOfVariablesAnalyzer',
     IObjectExpressionExtractor = 'IObjectExpressionExtractor',
     IRandomGenerator = 'IRandomGenerator',
+    IRenamePropertiesReplacer = 'IRenamePropertiesReplacer',
     IScopeIdentifiersTraverser = 'IScopeIdentifiersTraverser',
     ISourceCode = 'ISourceCode',
     IScopeAnalyzer = 'IScopeAnalyzer',

src/container/modules/node-transformers/ManglePropertiesTransformersModule.ts

@@ -1,21 +0,0 @@
-import { ContainerModule, interfaces } from 'inversify';
-import { ServiceIdentifiers } from '../../ServiceIdentifiers';
-
-import { IManglePropertiesReplacer } from '../../../interfaces/node-transformers/mangle-properties-transformers/replacer/IManglePropertiesReplacer';
-import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
-
-import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
-
-import { ManglePropertiesReplacer } from '../../../node-transformers/mangle-properties-transformers/replacer/ManglePropertiesReplacer';
-import { ManglePropertiesTransformer } from '../../../node-transformers/mangle-properties-transformers/ManglePropertiesTransformer';
-
-export const manglePropertiesTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
-    // mangle properties transformers
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(ManglePropertiesTransformer)
-        .whenTargetNamed(NodeTransformer.ManglePropertiesTransformer);
-
-    // mangle properties obfuscating replacer
-    bind<IManglePropertiesReplacer>(ServiceIdentifiers.IManglePropertiesObfuscatingReplacer)
-        .to(ManglePropertiesReplacer);
-});

src/container/modules/node-transformers/RenamePropertiesTransformersModule.ts

@@ -0,0 +1,21 @@
+import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { IRenamePropertiesReplacer } from '../../../interfaces/node-transformers/rename-properties-transformers/replacer/IRenamePropertiesReplacer';
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { RenamePropertiesReplacer } from '../../../node-transformers/rename-properties-transformers/replacer/RenamePropertiesReplacer';
+import { RenamePropertiesTransformer } from '../../../node-transformers/rename-properties-transformers/RenamePropertiesTransformer';
+
+export const renamePropertiesTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+    // rename properties transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(RenamePropertiesTransformer)
+        .whenTargetNamed(NodeTransformer.RenamePropertiesTransformer);
+
+    // rename properties obfuscating replacer
+    bind<IRenamePropertiesReplacer>(ServiceIdentifiers.IRenamePropertiesReplacer)
+        .to(RenamePropertiesReplacer);
+});

src/enums/node-transformers/NodeTransformationStage.ts

@@ -1,9 +1,9 @@
 export enum NodeTransformationStage {
     Initializing = 'Initializing',
     Preparing = 'Preparing',
-    MangleProperties = 'MangleProperties',
     DeadCodeInjection = 'DeadCodeInjection',
     ControlFlowFlattening = 'ControlFlowFlattening',
+    RenameProperties = 'RenameProperties',
     Converting = 'Converting',
     Obfuscating = 'Obfuscating',
     Finalizing = 'Finalizing'

src/enums/node-transformers/NodeTransformer.ts

@@ -7,7 +7,6 @@ export enum NodeTransformer {
     FunctionControlFlowTransformer = 'FunctionControlFlowTransformer',
     LabeledStatementTransformer = 'LabeledStatementTransformer',
     LiteralTransformer = 'LiteralTransformer',
-    ManglePropertiesTransformer = 'ManglePropertiesTransformer',
     MemberExpressionTransformer = 'MemberExpressionTransformer',
     MetadataTransformer = 'MetadataTransformer',
     MethodDefinitionTransformer = 'MethodDefinitionTransformer',
@@ -15,6 +14,7 @@ export enum NodeTransformer {
     ObjectExpressionKeysTransformer = 'ObjectExpressionKeysTransformer',
     ObjectExpressionTransformer = 'ObjectExpressionTransformer',
     ParentificationTransformer = 'ParentificationTransformer',
+    RenamePropertiesTransformer = 'RenamePropertiesTransformer',
     ScopeIdentifiersTransformer = 'ScopeIdentifiersTransformer',
     SplitStringTransformer = 'SplitStringTransformer',
     TemplateLiteralTransformer = 'TemplateLiteralTransformer',

src/interfaces/node-transformers/rename-properties-transformers/replacer/IRenamePropertiesReplacer.ts

@@ -1,6 +1,6 @@
 import * as ESTree from 'estree';
 
-export interface IManglePropertiesReplacer {
+export interface IRenamePropertiesReplacer {
     /**
      * @param {ESTree.Identifier | ESTree.Literal} node
      * @returns {ESTree.Identifier | ESTree.Literal}

src/interfaces/options/IOptions.ts

@@ -21,8 +21,8 @@ export interface IOptions {
     readonly identifiersPrefix: string;
     readonly inputFileName: string;
     readonly log: boolean;
-    readonly mangleProperties: boolean;
     readonly renameGlobals: boolean;
+    readonly renameProperties: boolean;
     readonly reservedNames: string[];
     readonly reservedStrings: string[];
     readonly rotateStringArray: boolean;

src/node-transformers/rename-properties-transformers/RenamePropertiesTransformer.ts

@@ -3,7 +3,7 @@ import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
 
 import * as ESTree from 'estree';
 
-import { IManglePropertiesReplacer } from '../../interfaces/node-transformers/mangle-properties-transformers/replacer/IManglePropertiesReplacer';
+import { IRenamePropertiesReplacer } from '../../interfaces/node-transformers/rename-properties-transformers/replacer/IRenamePropertiesReplacer';
 import { IOptions } from '../../interfaces/options/IOptions';
 import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
@@ -14,26 +14,25 @@ import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
 
 @injectable()
-export class ManglePropertiesTransformer extends AbstractNodeTransformer {
+export class RenamePropertiesTransformer extends AbstractNodeTransformer {
     /**
-     * @type {IManglePropertiesReplacer}
+     * @type {IRenamePropertiesReplacer}
      */
-    private readonly manglePropertiesObfuscatingReplacer: IManglePropertiesReplacer;
+    private readonly renamePropertiesReplacer: IRenamePropertiesReplacer;
 
     /**
-     * @param {IManglePropertiesReplacer} manglePropertiesObfuscatingReplacer
+     * @param {IRenamePropertiesReplacer} renamePropertiesReplacer
      * @param {IRandomGenerator} randomGenerator
      * @param {IOptions} options
      */
     public constructor (
-        @inject(ServiceIdentifiers.IManglePropertiesObfuscatingReplacer)
-            manglePropertiesObfuscatingReplacer: IManglePropertiesReplacer,
+        @inject(ServiceIdentifiers.IRenamePropertiesReplacer) renamePropertiesReplacer: IRenamePropertiesReplacer,
         @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
         @inject(ServiceIdentifiers.IOptions) options: IOptions
     ) {
         super(randomGenerator, options);
 
-        this.manglePropertiesObfuscatingReplacer = manglePropertiesObfuscatingReplacer;
+        this.renamePropertiesReplacer = renamePropertiesReplacer;
     }
 
     /**
@@ -60,7 +59,7 @@ export class ManglePropertiesTransformer extends AbstractNodeTransformer {
      */
     public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
         switch (nodeTransformationStage) {
-            case NodeTransformationStage.MangleProperties:
+            case NodeTransformationStage.RenameProperties:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (parentNode) {
@@ -104,8 +103,8 @@ export class ManglePropertiesTransformer extends AbstractNodeTransformer {
     private transformPropertyNode (propertyNode: ESTree.Property): ESTree.Property {
         const propertyKeyNode: ESTree.Expression = propertyNode.key;
 
-        if (ManglePropertiesTransformer.isValidPropertyNode(propertyNode, propertyKeyNode)) {
-            propertyNode.key = this.manglePropertiesObfuscatingReplacer.replace(propertyKeyNode);
+        if (RenamePropertiesTransformer.isValidPropertyNode(propertyNode, propertyKeyNode)) {
+            propertyNode.key = this.renamePropertiesReplacer.replace(propertyKeyNode);
             propertyNode.shorthand = false;
         }
 
@@ -119,8 +118,8 @@ export class ManglePropertiesTransformer extends AbstractNodeTransformer {
     private transformMemberExpressionNode (memberExpressionNode: ESTree.MemberExpression): ESTree.MemberExpression {
         const propertyKeyNode: ESTree.Expression = memberExpressionNode.property;
 
-        if (ManglePropertiesTransformer.isValidPropertyNode(memberExpressionNode, propertyKeyNode)) {
-            memberExpressionNode.property = this.manglePropertiesObfuscatingReplacer.replace(propertyKeyNode);
+        if (RenamePropertiesTransformer.isValidPropertyNode(memberExpressionNode, propertyKeyNode)) {
+            memberExpressionNode.property = this.renamePropertiesReplacer.replace(propertyKeyNode);
         }
 
         return memberExpressionNode;
@@ -133,8 +132,8 @@ export class ManglePropertiesTransformer extends AbstractNodeTransformer {
     private transformMethodDefinitionNode (methodDefinitionNode: ESTree.MethodDefinition): ESTree.MethodDefinition {
         const propertyKeyNode: ESTree.Expression = methodDefinitionNode.key;
 
-        if (ManglePropertiesTransformer.isValidPropertyNode(methodDefinitionNode, propertyKeyNode)) {
-            methodDefinitionNode.key = this.manglePropertiesObfuscatingReplacer.replace(propertyKeyNode);
+        if (RenamePropertiesTransformer.isValidPropertyNode(methodDefinitionNode, propertyKeyNode)) {
+            methodDefinitionNode.key = this.renamePropertiesReplacer.replace(propertyKeyNode);
         }
 
         return methodDefinitionNode;

src/node-transformers/rename-properties-transformers/replacer/RenamePropertiesReplacer.ts

@@ -6,7 +6,7 @@ import * as ESTree from 'estree';
 import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
 
 import { IIdentifierNamesGenerator } from '../../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
-import { IManglePropertiesReplacer } from '../../../interfaces/node-transformers/mangle-properties-transformers/replacer/IManglePropertiesReplacer';
+import { IRenamePropertiesReplacer } from '../../../interfaces/node-transformers/rename-properties-transformers/replacer/IRenamePropertiesReplacer';
 import { IOptions } from '../../../interfaces/options/IOptions';
 
 import { ReservedDomProperties } from '../../../constants/ReservedDomProperties';
@@ -15,7 +15,7 @@ import { NodeGuards } from '../../../node/NodeGuards';
 import { NodeFactory } from '../../../node/NodeFactory';
 
 @injectable()
-export class ManglePropertiesReplacer implements IManglePropertiesReplacer {
+export class RenamePropertiesReplacer implements IRenamePropertiesReplacer {
     /**
      * @type {IIdentifierNamesGenerator}
      */
@@ -25,7 +25,7 @@ export class ManglePropertiesReplacer implements IManglePropertiesReplacer {
      * @type {Map<string, string>}
      * @private
      */
-    private readonly mangledPropertyNamesMap: Map<string, string> = new Map();
+    private readonly propertyNamesMap: Map<string, string> = new Map();
 
     /**
      * @type {IOptions}
@@ -81,16 +81,16 @@ export class ManglePropertiesReplacer implements IManglePropertiesReplacer {
             return propertyName;
         }
 
-        let mangledPropertyName: string | null = this.mangledPropertyNamesMap.get(propertyName) ?? null;
+        let renamedPropertyName: string | null = this.propertyNamesMap.get(propertyName) ?? null;
 
-        if (mangledPropertyName !== null) {
-            return mangledPropertyName;
+        if (renamedPropertyName !== null) {
+            return renamedPropertyName;
         }
 
-        mangledPropertyName = this.identifierNamesGenerator.generateNext();
-        this.mangledPropertyNamesMap.set(propertyName, mangledPropertyName);
+        renamedPropertyName = this.identifierNamesGenerator.generateNext();
+        this.propertyNamesMap.set(propertyName, renamedPropertyName);
 
-        return mangledPropertyName;
+        return renamedPropertyName;
     }
 
     /**

src/options/Options.ts

@@ -154,13 +154,13 @@ export class Options implements IOptions {
      * @type {boolean}
      */
     @IsBoolean()
-    public readonly mangleProperties!: boolean;
+    public readonly renameGlobals!: boolean;
 
     /**
      * @type {boolean}
      */
     @IsBoolean()
-    public readonly renameGlobals!: boolean;
+    public readonly renameProperties!: boolean;
 
     /**
      * @type {string[]}

src/options/presets/Default.ts

@@ -21,8 +21,8 @@ export const DEFAULT_PRESET: TInputOptions = Object.freeze({
     identifiersDictionary: [],
     inputFileName: '',
     log: false,
-    mangleProperties: false,
     renameGlobals: false,
+    renameProperties: false,
     reservedNames: [],
     reservedStrings: [],
     rotateStringArray: true,

src/options/presets/NoCustomNodes.ts

@@ -20,8 +20,8 @@ export const NO_ADDITIONAL_NODES_PRESET: TInputOptions = Object.freeze({
     identifiersDictionary: [],
     inputFileName: '',
     log: false,
-    mangleProperties: false,
     renameGlobals: false,
+    renameProperties: false,
     reservedNames: [],
     reservedStrings: [],
     rotateStringArray: false,