Code coverage report for src/custom-nodes/unicode-array-nodes/UnicodeArrayDecodeNode.ts

# All files / src/custom-nodes/unicode-array-nodes UnicodeArrayDecodeNode.ts

100% Statements 24/24
83.33% Branches 5/6
100% Functions 1/1
100% Lines 24/24

    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

    1x

    1x

    1x

    1x
    1x
    1x

    1x
    1x
    1x

    1x

    4x

    4x

    4x
    4x

    4x
    2x

    2x

    2x

    2x

    2x

    2x
    1x

    1x

    2x

     import * as ESTree from 'estree';

    import 'format-unicorn';

    import { IOptions } from '../../interfaces/IOptions';

    import { TNodeWithBlockStatement } from '../../types/TNodeWithBlockStatement';

    import { AppendState } from '../../enums/AppendState';

    import { NO_CUSTOM_NODES_PRESET } from '../../preset-options/NoCustomNodesPreset';

    import { AtobTemplate } from '../../templates/custom-nodes/AtobTemplate';
    import { SelfDefendingTemplate } from '../../templates/custom-nodes/unicode-array-nodes/unicode-array-decode-node/SelfDefendingTemplate';
    import { UnicodeArrayDecodeNodeTemplate } from '../../templates/custom-nodes/unicode-array-nodes/unicode-array-decode-node/UnicodeArrayDecodeNodeTemplate';

    import { AbstractCustomNode } from '../AbstractCustomNode';
    import { JavaScriptObfuscator } from '../../JavaScriptObfuscator';
    import { NodeUtils } from '../../NodeUtils';
    import { UnicodeArray } from '../../UnicodeArray';

    export class UnicodeArrayDecodeNode extends AbstractCustomNode {
        /**
         * @type {AppendState}
         */
        protected appendState: AppendState = AppendState.AfterObfuscation;

        /**
         * @type {UnicodeArray}
         */
        private unicodeArray: UnicodeArray;

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

        /**
         * @param unicodeArrayName
         * @param unicodeArray
         * @param options
         */
        constructor (
            unicodeArrayName: string,
            unicodeArray: UnicodeArray,
            options: IOptions
        ) {
            super(options);

            this.unicodeArrayName = unicodeArrayName;
            this.unicodeArray = unicodeArray;
        }

        /**
         * @param blockScopeNode
         */
        public appendNode (blockScopeNode: TNodeWithBlockStatement): void {
            if (!this.unicodeArray.getLength()) {
                return;
            }

            NodeUtils.insertNodeAtIndex(blockScopeNode.body, this.getNode(), 1);
        }

        /**
         * @returns {ESTree.Node}
         */
        public getNode (): ESTree.Node {
            return super.getNode();
        }

        /**
         * @returns {ESTree.Node}
         */
        protected getNodeStructure (): ESTree.Node {
            const forLoopFunctionName: string = 'forLoopFunc';

            let code: string;

            if (this.options.selfDefending) {
                code = SelfDefendingTemplate().formatUnicorn({
                    forLoopFunctionName,
                    unicodeArrayName: this.unicodeArrayName
                });
            } else {
                code = `${forLoopFunctionName}();`;
            }

            return NodeUtils.convertCodeToStructure(
                JavaScriptObfuscator.obfuscate(
                    UnicodeArrayDecodeNodeTemplate().formatUnicorn({
                        atobPolyfill: AtobTemplate(),
                        code,
                        forLoopFunctionName,
                        unicodeArrayName: this.unicodeArrayName
                    }),
                    NO_CUSTOM_NODES_PRESET
                ).getObfuscatedCode()
            );
        }
    }