Code coverage report for src/node-transformers/node-obfuscators/MemberExpressionTransformer.ts

# All files / src/node-transformers/node-obfuscators MemberExpressionTransformer.ts

100% Statements 19/19
100% Branches 4/4
100% Functions 1/1
100% Lines 16/16

    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
    751x
    1x

    1x
    1x

    1x
    1x

    1x

    2416x

    2416x

    27569x
    25979x
    587x

    25392x
    25392x

    26982x

    25392x

     import { injectable, inject } from 'inversify';
    import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';

    import * as ESTree from 'estree';

    import { IOptions } from '../../interfaces/options/IOptions';
    import { IObfuscatorReplacer } from '../../interfaces/node-transformers/IObfuscatorReplacer';

    import { NodeObfuscatorsReplacers } from '../../enums/container/NodeObfuscatorsReplacers';
    import { NodeType } from '../../enums/NodeType';

    import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
    import { Node } from '../../node/Node';

    @injectable()
    export class MemberExpressionObfuscator extends AbstractNodeTransformer {
        /**
         * @type {IObfuscatorReplacer}
         */
        private readonly stringLiteralReplacer: IObfuscatorReplacer;

        /**
         * @param replacersFactory
         * @param options
         */
        constructor(
            @inject(ServiceIdentifiers.Factory__IObfuscatorReplacer) replacersFactory: (replacer: NodeObfuscatorsReplacers) => IObfuscatorReplacer,
            @inject(ServiceIdentifiers.IOptions) options: IOptions
        ) {
            super(options);

            this.stringLiteralReplacer = replacersFactory(NodeObfuscatorsReplacers.StringLiteralReplacer);
        }

        /**
         * @param memberExpressionNode
         * @returns {ESTree.Node}
         */
        public transformNode (memberExpressionNode: ESTree.MemberExpression): ESTree.Node {
            if (Node.isIdentifierNode(memberExpressionNode.property)) {
                if (memberExpressionNode.computed) {
                    return memberExpressionNode;
                }

                memberExpressionNode.computed = true;
                memberExpressionNode.property = this.obfuscateIdentifierProperty(memberExpressionNode.property);
            }

            return memberExpressionNode;
        }

        /**
         * replaces:
         *     object.identifier = 1;
         *
         * on:
         *     object['identifier'] = 1;
         *
         * and skip:
         *     object[identifier] = 1;
         *
         * Literal node will be obfuscated by LiteralObfuscator
         *
         * @param node
         * @returns {ESTree.Literal}
         */
        private obfuscateIdentifierProperty (node: ESTree.Identifier): ESTree.Literal {
            return {
                type: NodeType.Literal,
                value: node.name,
                raw: `'${node.name}'`
            };
        }
    }