selfDefending test implementation

dist/src/OptionsNormalizer.js

@@ -3,6 +3,7 @@ class OptionsNormalizer {
     static normalize(options) {
         let normalizedOptions = Object.assign({}, options);
         normalizedOptions = OptionsNormalizer.unicodeArrayRule(normalizedOptions);
+        normalizedOptions = OptionsNormalizer.unicodeArrayThresholdRule(normalizedOptions);
         normalizedOptions = OptionsNormalizer.selfDefendingRule(normalizedOptions);
         return normalizedOptions;
     }
@@ -18,6 +19,11 @@ class OptionsNormalizer {
         }
         return options;
     }
+    static unicodeArrayThresholdRule(options) {
+        const minValue = 0, maxValue = 1;
+        options['unicodeArrayThreshold'] = Math.min(Math.max(options['unicodeArrayThreshold'], minValue), maxValue);
+        return options;
+    }
 }
 OptionsNormalizer.DISABLED_UNICODE_ARRAY_OPTIONS = {
     encodeUnicodeLiterals: false,

dist/src/node-obfuscators/NodeObfuscator.js

@@ -35,12 +35,12 @@ class NodeObfuscator {
         return `${prefix}${Utils_1.Utils.decToHex(nodeValue)}`;
     }
     replaceLiteralValueByUnicodeValue(nodeValue) {
-        let value = nodeValue;
-        if (this.options['encodeUnicodeLiterals']) {
+        let value = nodeValue, replaceByUnicodeArrayFlag = Math.random() > this.options['unicodeArrayThreshold'];
+        if (this.options['encodeUnicodeLiterals'] && replaceByUnicodeArrayFlag) {
             value = new Buffer(encodeURI(value)).toString('base64');
         }
         value = Utils_1.Utils.stringToUnicode(value);
-        if (!this.options['unicodeArray']) {
+        if (!this.options['unicodeArray'] || !replaceByUnicodeArrayFlag) {
             return value;
         }
         return this.replaceLiteralValueByUnicodeArrayCall(value);

dist/src/preset-options/DefaultPreset.js

@@ -9,5 +9,6 @@ exports.DEFAULT_PRESET = Object.freeze({
     rotateUnicodeArray: true,
     selfDefending: true,
     unicodeArray: true,
+    unicodeArrayThreshold: 0.8,
     wrapUnicodeArrayCalls: true
 });

dist/src/preset-options/NoCustomNodesPreset.js

@@ -9,5 +9,6 @@ exports.NO_CUSTOM_NODES_PRESET = Object.freeze({
     rotateUnicodeArray: false,
     selfDefending: false,
     unicodeArray: false,
+    unicodeArrayThreshold: 0,
     wrapUnicodeArrayCalls: false
 });

readme.md

@@ -123,6 +123,16 @@ Type: `boolean` Default: `true`
 
 Put all literal strings into array and replace every literal string by array call.
 
+####unicodeArrayThreshold
+Type: `number` Default: `0.8` Min: `0` Max: `1`
+
+#####`unicodeArray` option must be enabled
+
+Probability that the literal string will inserted into `unicodeArray`.
+Use this option for huge source code size, because many calls to `unicodeArray` will slowdown code performance.
+
+Value `0` is equals `unicodeArray: false`.
+
 ####wrapUnicodeArrayCalls
 Type: `boolean` Default: `true`
 

src/OptionsNormalizer.ts

@@ -27,6 +27,7 @@ export class OptionsNormalizer {
         let normalizedOptions: IOptions = Object.assign({}, options);
 
         normalizedOptions = OptionsNormalizer.unicodeArrayRule(normalizedOptions);
+        normalizedOptions = OptionsNormalizer.unicodeArrayThresholdRule(normalizedOptions);
         normalizedOptions = OptionsNormalizer.selfDefendingRule(normalizedOptions);
 
         return normalizedOptions;
@@ -55,4 +56,23 @@ export class OptionsNormalizer {
 
         return options;
     }
-}
+
+    /**
+     * @param options
+     * @returns {IOptions}
+     */
+    private static unicodeArrayThresholdRule (options: IOptions): IOptions {
+        const minValue: number = 0,
+            maxValue: number = 1;
+
+        options['unicodeArrayThreshold'] = Math.min(
+            Math.max(
+                options['unicodeArrayThreshold'],
+                minValue
+            ),
+            maxValue
+        );
+
+        return options;
+    }
+}

src/interfaces/IOptions.d.ts

@@ -8,5 +8,6 @@ export interface IOptions {
     rotateUnicodeArray?: boolean;
     selfDefending?: boolean;
     unicodeArray?: boolean;
+    unicodeArrayThreshold?: number;
     wrapUnicodeArrayCalls?: boolean;
 }

src/node-obfuscators/NodeObfuscator.ts

@@ -97,19 +97,20 @@ export abstract class NodeObfuscator implements INodeObfuscator {
      * @returns {string}
      */
     protected replaceLiteralValueByUnicodeValue (nodeValue: string): string {
-        let value: string = nodeValue;
+        let value: string = nodeValue,
+            replaceByUnicodeArrayFlag: boolean = Math.random() > this.options['unicodeArrayThreshold'];
 
-        if (this.options['encodeUnicodeLiterals']) {
+        if (this.options['encodeUnicodeLiterals'] && replaceByUnicodeArrayFlag) {
             value = new Buffer(encodeURI(value)).toString('base64');
         }
 
         value = Utils.stringToUnicode(value);
 
-        if (!this.options['unicodeArray']) {
+        if (!this.options['unicodeArray'] || !replaceByUnicodeArrayFlag) {
             return value;
         }
 
-        return this.replaceLiteralValueByUnicodeArrayCall(value)
+        return this.replaceLiteralValueByUnicodeArrayCall(value);
     }
 
     /**

src/preset-options/DefaultPreset.ts

@@ -10,5 +10,6 @@ export const DEFAULT_PRESET: IOptions = Object.freeze({
     rotateUnicodeArray: true,
     selfDefending: true,
     unicodeArray: true,
+    unicodeArrayThreshold: 0.8,
     wrapUnicodeArrayCalls: true
 });

src/preset-options/NoCustomNodesPreset.ts

@@ -10,5 +10,6 @@ export const NO_CUSTOM_NODES_PRESET: IOptions = Object.freeze({
     rotateUnicodeArray: false,
     selfDefending: false,
     unicodeArray: false,
+    unicodeArrayThreshold: 0,
     wrapUnicodeArrayCalls: false
 });