EscapeSequenceTransformer moved to the Finalizing transformers

src/JavaScriptObfuscator.ts

@@ -225,7 +225,7 @@ export class JavaScriptObfuscator implements IJavaScriptObfuscator {
 
         astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Converting);
         astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.RenameIdentifiers);
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Strings);
+        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.StringArray);
 
         if (this.options.simplify) {
             astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Simplifying);

src/container/InversifyContainerFacade.ts

@@ -19,7 +19,7 @@ import { renameIdentifiersTransformersModule } from './modules/node-transformers
 import { renamePropertiesTransformersModule } from './modules/node-transformers/RenamePropertiesTransformersModule';
 import { simplifyingTransformersModule } from './modules/node-transformers/SimplifyingTransformersModule';
 import { storagesModule } from './modules/storages/StoragesModule';
-import { stringsTransformersModule } from './modules/node-transformers/StringsTransformersModule';
+import { stringArrayTransformersModule } from './modules/node-transformers/StringArrayTransformersModule';
 import { utilsModule } from './modules/utils/UtilsModule';
 
 import { TInputOptions } from '../types/options/TInputOptions';
@@ -223,7 +223,7 @@ export class InversifyContainerFacade implements IInversifyContainerFacade {
         this.container.load(renamePropertiesTransformersModule);
         this.container.load(simplifyingTransformersModule);
         this.container.load(storagesModule);
-        this.container.load(stringsTransformersModule);
+        this.container.load(stringArrayTransformersModule);
         this.container.load(utilsModule);
     }
 

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

@@ -1,5 +1,15 @@
 import { ContainerModule, interfaces } from 'inversify';
+import { ServiceIdentifiers } from '../../ServiceIdentifiers';
+
+import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTransformer';
+
+import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
+
+import { EscapeSequenceTransformer } from '../../../node-transformers/finalizing-transformers/EscapeSequenceTransformer';
 
 export const finalizingTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // finalizing transformers
+    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
+        .to(EscapeSequenceTransformer)
+        .whenTargetNamed(NodeTransformer.EscapeSequenceTransformer);
 });

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

@@ -5,16 +5,11 @@ import { INodeTransformer } from '../../../interfaces/node-transformers/INodeTra
 
 import { NodeTransformer } from '../../../enums/node-transformers/NodeTransformer';
 
-import { EscapeSequenceTransformer } from '../../../node-transformers/strings-transformers/EscapeSequenceTransformer';
-import { StringArrayScopeCallsWrapperTransformer } from '../../../node-transformers/strings-transformers/StringArrayScopeCallsWrapperTransformer';
-import { StringArrayTransformer } from '../../../node-transformers/strings-transformers/StringArrayTransformer';
+import { StringArrayScopeCallsWrapperTransformer } from '../../../node-transformers/string-array-transformers/StringArrayScopeCallsWrapperTransformer';
+import { StringArrayTransformer } from '../../../node-transformers/string-array-transformers/StringArrayTransformer';
 
-export const stringsTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
+export const stringArrayTransformersModule: interfaces.ContainerModule = new ContainerModule((bind: interfaces.Bind) => {
     // strings transformers
-    bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
-        .to(EscapeSequenceTransformer)
-        .whenTargetNamed(NodeTransformer.EscapeSequenceTransformer);
-
     bind<INodeTransformer>(ServiceIdentifiers.INodeTransformer)
         .to(StringArrayScopeCallsWrapperTransformer)
         .whenTargetNamed(NodeTransformer.StringArrayScopeCallsWrapperTransformer);

src/enums/node-transformers/NodeTransformationStage.ts

@@ -8,5 +8,5 @@ export enum NodeTransformationStage {
     RenameIdentifiers = 'RenameIdentifiers',
     RenameProperties = 'RenameProperties',
     Simplifying = 'Simplifying',
-    Strings = 'Strings'
+    StringArray = 'StringArray'
 }

src/node-transformers/finalizing-transformers/EscapeSequenceTransformer.ts

@@ -9,7 +9,6 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
@@ -19,14 +18,6 @@ import { NodeUtils } from '../../node/NodeUtils';
 
 @injectable()
 export class EscapeSequenceTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {NodeTransformer[]}
-     */
-    public readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.StringArrayScopeCallsWrapperTransformer,
-        NodeTransformer.StringArrayTransformer
-    ];
-
     /**
      * @type {IEscapeSequenceEncoder}
      */
@@ -53,7 +44,7 @@ export class EscapeSequenceTransformer extends AbstractNodeTransformer {
      */
     public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
         switch (nodeTransformationStage) {
-            case NodeTransformationStage.Strings:
+            case NodeTransformationStage.Finalizing:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (NodeGuards.isLiteralNode(node)) {

src/node-transformers/string-array-transformers/StringArrayScopeCallsWrapperTransformer.ts

@@ -95,7 +95,7 @@ export class StringArrayScopeCallsWrapperTransformer extends AbstractNodeTransfo
         }
 
         switch (nodeTransformationStage) {
-            case NodeTransformationStage.Strings:
+            case NodeTransformationStage.StringArray:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): void => {
                         if (parentNode && NodeGuards.isNodeWithLexicalScopeStatements(node, parentNode)) {

src/node-transformers/string-array-transformers/StringArrayTransformer.ts

@@ -29,7 +29,6 @@ import { StringArrayCustomNode } from '../../enums/custom-nodes/StringArrayCusto
 import { StringArrayWrappersType } from '../../enums/node-transformers/string-array-transformers/StringArrayWrappersType';
 
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeFactory } from '../../node/NodeFactory';
 import { NodeGuards } from '../../node/NodeGuards';
 import { NodeLiteralUtils } from '../../node/NodeLiteralUtils';
 import { NodeMetadata } from '../../node/NodeMetadata';
@@ -135,7 +134,7 @@ export class StringArrayTransformer extends AbstractNodeTransformer {
      */
     public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
         switch (nodeTransformationStage) {
-            case NodeTransformationStage.Strings:
+            case NodeTransformationStage.StringArray:
                 return {
                     enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
                         if (NodeGuards.isProgramNode(node)) {
@@ -194,7 +193,7 @@ export class StringArrayTransformer extends AbstractNodeTransformer {
 
         const resultNode: ESTree.Node = stringArrayStorageItemData
             ? this.getStringArrayCallNode(stringArrayStorageItemData)
-            : this.getLiteralNode(literalValue);
+            : literalNode;
 
         this.literalNodesCacheStorage.set(cacheKey, resultNode);
 
@@ -203,14 +202,6 @@ export class StringArrayTransformer extends AbstractNodeTransformer {
         return resultNode;
     }
 
-    /**
-     * @param {string} value
-     * @returns {Node}
-     */
-    private getLiteralNode (value: string): ESTree.Node {
-        return NodeFactory.literalNode(value);
-    }
-
     /**
      * @param {IStringArrayStorageItemData} stringArrayStorageItemData
      * @returns {Node}