Code coverage report for src/JavaScriptObfuscatorInternal.ts

# All files / src JavaScriptObfuscatorInternal.ts

100% Statements 27/27
90% Branches 9/10
100% Functions 1/1
100% Lines 27/27

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    1061x
    1x

    1x

    1x
    1x
    1x
    1x
    1x

    1x

    1x

    2621x
    2621x
    2621x

    2621x

    2621x
    9x
    9x

    2621x

    2621x

    2621x

    2621x

    2621x

    2621x

    2621x
    20x

    2621x

    2621x

     import * as esprima from 'esprima';
    import * as escodegen from 'escodegen';
    import * as ESTree from 'estree';

    import { Chance } from 'chance';

    import { IObfuscatorOptions } from './interfaces/IObfuscatorOptions';
    import { IGeneratorOutput } from './interfaces/IGeneratorOutput';
    import { IObfuscationResult } from './interfaces/IObfuscationResult';
    import { IOptions } from './interfaces/IOptions';

    import { ObfuscationResult } from './ObfuscationResult';
    import { Obfuscator } from './Obfuscator';
    import { Options } from './options/Options';
    import { SourceMapCorrector } from './SourceMapCorrector';
    import { Utils } from './Utils';

    export class JavaScriptObfuscatorInternal {
        /**
         * @type {GenerateOptions}
         */
        private static escodegenParams: escodegen.GenerateOptions = {
            verbatim: 'x-verbatim-property',
            sourceMapWithCode: true
        };

        /**
         * @type {IGeneratorOutput}
         */
        private generatorOutput: IGeneratorOutput;

        /**
         * @type {IOptions}
         */
        private options: IOptions;

        /**
         * @type {string}
         */
        private sourceCode: string;

        /**
         * @param sourceCode
         * @param obfuscatorOptions
         */
        constructor (sourceCode: string, obfuscatorOptions: IObfuscatorOptions = {}) {
            this.sourceCode = sourceCode;
            this.options = new Options(obfuscatorOptions);
        }

        /**
         * @param sourceCode
         * @param astTree
         * @param options
         */
        private static generateCode (sourceCode: string, astTree: ESTree.Node, options: IOptions): IGeneratorOutput {
            const escodegenParams: escodegen.GenerateOptions = Object.assign(
                {},
                JavaScriptObfuscatorInternal.escodegenParams
            );

            if (options.sourceMap) {
                escodegenParams.sourceMap = 'sourceMap';
                escodegenParams.sourceContent = sourceCode;
            }

            escodegenParams.format = {
                compact: options.compact
            };

            const generatorOutput: IGeneratorOutput = escodegen.generate(astTree, escodegenParams);

            generatorOutput.map = generatorOutput.map ? generatorOutput.map.toString() : '';

            return generatorOutput;
        }

        /**
         * @returns {IObfuscationResult}
         */
        public getObfuscationResult (): IObfuscationResult {
            return new SourceMapCorrector(
                new ObfuscationResult(
                    this.generatorOutput.code,
                    this.generatorOutput.map
                ),
                this.options.sourceMapBaseUrl + this.options.sourceMapFileName,
                this.options.sourceMapMode
            ).correct();
        }

        public obfuscate (): void {
            let astTree: ESTree.Node = esprima.parse(this.sourceCode, {
                loc: true
            });

            if (this.options.seed !== 0) {
                Utils.setRandomGenerator(new Chance(this.options.seed));
            }

            astTree = new Obfuscator(this.options).obfuscateNode(astTree);

            this.generatorOutput = JavaScriptObfuscatorInternal.generateCode(this.sourceCode, astTree, this.options);
        }
    }