refactoring

sanex3339 · sanex3339 · commit f47dbdd4c7bf · 2016-12-23T18:58:57.000+03:00
diff --git a/dist/index.js b/dist/index.js
diff --git a/src/node-transformers/node-obfuscators/ObjectExpressionObfuscator.ts b/src/node-transformers/node-obfuscators/ObjectExpressionObfuscator.ts
@@ -34,61 +34,58 @@ export class ObjectExpressionObfuscator extends AbstractNodeTransformer {
         super(options);
     }
 
-    /**
-     * @param objectExpressionNode
-     */
-    public transformNode (objectExpressionNode: ESTree.ObjectExpression): void {
-        objectExpressionNode.properties
-            .forEach((property: ESTree.Property) => {
-                if (property.shorthand) {
-                    property.shorthand = false;
-                }
-
-                estraverse.traverse(property.key, {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
-                        if (Node.isLiteralNode(node)) {
-                            this.obfuscateLiteralPropertyKey(node);
-
-                            return;
-                        }
-
-                        if (Node.isIdentifierNode(node)) {
-                            this.obfuscateIdentifierPropertyKey(node);
-                        }
-                    }
-                });
-            });
-    }
-
     /**
      * @param node
+     * @returns {ESTree.Literal}
      */
-    private obfuscateLiteralPropertyKey (node: ESTree.Literal): void {
+    private static obfuscateLiteralPropertyKey (node: ESTree.Literal): ESTree.Literal {
         if (typeof node.value === 'string' && !node['x-verbatim-property']) {
             node['x-verbatim-property'] = {
                 content : `'${Utils.stringToUnicodeEscapeSequence(node.value)}'`,
                 precedence: escodegen.Precedence.Primary
             };
         }
+
+        return node;
     }
 
     /**
      * @param node
+     * @returns {ESTree.Literal}
      */
-    private obfuscateIdentifierPropertyKey (node: ESTree.Identifier): void {
-        const nodeValue: string = node.name;
-        const literalNode: ESTree.Literal = {
-            raw: `'${nodeValue}'`,
+    private static obfuscateIdentifierPropertyKey (node: ESTree.Identifier): ESTree.Literal {
+        return {
+            type: NodeType.Literal,
+            value: node.name,
+            raw: `'${node.name}'`,
             'x-verbatim-property': {
-                content : `'${Utils.stringToUnicodeEscapeSequence(nodeValue)}'`,
+                content : `'${Utils.stringToUnicodeEscapeSequence(node.name)}'`,
                 precedence: escodegen.Precedence.Primary
-            },
-            type: NodeType.Literal,
-            value: nodeValue
+            }
         };
+    }
+
+    /**
+     * @param objectExpressionNode
+     */
+    public transformNode (objectExpressionNode: ESTree.ObjectExpression): void {
+        objectExpressionNode.properties
+            .forEach((property: ESTree.Property) => {
+                if (property.shorthand) {
+                    property.shorthand = false;
+                }
 
-        delete node.name;
+                estraverse.replace(property.key, {
+                    enter: (node: ESTree.Node, parentNode: ESTree.Node): any => {
+                        if (Node.isLiteralNode(node)) {
+                            property.key = ObjectExpressionObfuscator.obfuscateLiteralPropertyKey(node);
+                        }
 
-        Object.assign(node, literalNode);
+                        if (Node.isIdentifierNode(node)) {
+                            property.key = ObjectExpressionObfuscator.obfuscateIdentifierPropertyKey(node);
+                        }
+                    }
+                });
+            });
     }
 }
diff --git a/src/utils/Utils.ts b/src/utils/Utils.ts
@@ -7,6 +7,11 @@ export class Utils {
      */
     public static readonly hexadecimalPrefix: string = '0x';
 
+    /**
+     * @type {Map<string, string>}
+     */
+    private static readonly stringToUnicodeEscapeSequenceCache: Map <string, string> = new Map();
+
     /**
      * @param array
      * @param times
@@ -128,6 +133,12 @@ export class Utils {
      * @returns {string}
      */
     public static stringToUnicodeEscapeSequence (string: string, nonLatinAndNonDigitsOnly: boolean = false): string {
+        const cacheKey: string = `${string}-${String(nonLatinAndNonDigitsOnly)}`;
+
+        if (Utils.stringToUnicodeEscapeSequenceCache.has(cacheKey)) {
+            return <string>Utils.stringToUnicodeEscapeSequenceCache.get(cacheKey);
+        }
+
         const radix: number = 16;
         const replaceRegExp: RegExp = new RegExp('[\\s\\S]', 'g');
         const escapeRegExp: RegExp = new RegExp('[^a-zA-Z0-9]');
@@ -136,11 +147,11 @@ export class Utils {
         let prefix: string,
             template: string;
 
-        return `${string.replace(replaceRegExp, (escape: string): string => {
+        const result: string = string.replace(replaceRegExp, (escape: string): string => {
             if (nonLatinAndNonDigitsOnly && !escapeRegExp.test(escape)) {
                 return escape;
             }
-            
+
             if (regexp.test(escape)) {
                 prefix = '\\x';
                 template = '0'.repeat(2);
@@ -150,6 +161,10 @@ export class Utils {
             }
             
             return `${prefix}${(template + escape.charCodeAt(0).toString(radix)).slice(-template.length)}`;
-        })}`;
+        });
+
+        Utils.stringToUnicodeEscapeSequenceCache.set(cacheKey, result);
+
+        return result;
     }
 }
