javascript-obfuscator/src/custom-nodes/unicode-array-nodes/UnicodeArrayRotateFunctionNode.ts

import * as estraverse from 'estraverse';

import { INode } from '../../interfaces/nodes/INode';

import { NodeType } from "../../enums/NodeType";

import { Node } from '../Node';
import { NodeUtils } from "../../NodeUtils";
import { Utils } from '../../Utils';

export class UnicodeArrayRotateFunctionNode extends Node {
    /**
     * @type {string}
     */
    private unicodeArrayName: string;

    /**
     * @param {string}
     */
    private unicodeArrayRotateFunctionName: string;

    /**
     * @param unicodeArrayRotateFunctionName
     * @param unicodeArrayName
     */
    constructor (
        unicodeArrayRotateFunctionName: string,
        unicodeArrayName: string
    ) {
        super();

        this.unicodeArrayRotateFunctionName = unicodeArrayRotateFunctionName;
        this.unicodeArrayName = unicodeArrayName;

        this.node = this.getNodeStructure();
    }

    /**
     * @param astTree
     */
    public appendNode (astTree: INode): void {
        estraverse.replace(astTree, {
            leave: (node: INode, parent: INode): any => {
                if (NodeUtils.isProgramNode(node)) {
                    NodeUtils.appendNode(node.body, this.getNode());

                    return estraverse.VisitorOption.Break;
                }

                return estraverse.VisitorOption.Skip;
            }
        });
    }

    /**
     * @returns {string}
     */
    public getNodeIdentifier (): string {
        return this.unicodeArrayRotateFunctionName;
    }

    /**
     * @returns any
     */
    protected getNodeStructure (): any {
        return {
            'type': NodeType.FunctionExpression,
            'id': {
                'type': NodeType.Identifier,
                'name': this.unicodeArrayRotateFunctionName
            },
            'params': [
                {
                    'type': NodeType.Identifier,
                    'name': 'array'
                },
                {
                    'type': NodeType.Identifier,
                    'name': 'times'
                },
                {
                    'type': NodeType.Identifier,
                    'name': 'reverse'
                }
            ],
            'defaults': [],
            'body': {
                'type': NodeType.BlockStatement,
                'body': [
                    {
                        'type': NodeType.IfStatement,
                        'test': {
                            'type': NodeType.BinaryExpression,
                            'operator': '<',
                            'left': {
                                'type': NodeType.Identifier,
                                'name': 'times'
                            },
                            'right': {
                                'type': NodeType.Literal,
                                'value': 0,
                                'raw': '0'
                            }
                        },
                        'consequent': {
                            'type': NodeType.BlockStatement,
                            'body': [
                                {
                                    'type': NodeType.ReturnStatement,
                                    'argument': null
                                }
                            ]
                        },
                        'alternate': null
                    },
                    {
                        'type': NodeType.ExpressionStatement,
                        'expression': {
                            'type': NodeType.AssignmentExpression,
                            'operator': '=',
                            'left': {
                                'type': NodeType.Identifier,
                                'name': 'reverse'
                            },
                            'right': {
                                'type': NodeType.LogicalExpression,
                                'operator': '||',
                                'left': {
                                    'type': NodeType.Identifier,
                                    'name': 'reverse'
                                },
                                'right': {
                                    'type': NodeType.Literal,
                                    'value': false,
                                    'raw': 'false'
                                }
                            }
                        }
                    },
                    {
                        'type': NodeType.VariableDeclaration,
                        'declarations': [
                            {
                                'type': NodeType.VariableDeclarator,
                                'id': {
                                    'type': NodeType.Identifier,
                                    'name': 'temp'
                                },
                                'init': null
                            }
                        ],
                        'kind': 'var'
                    },
                    {
                        'type': NodeType.WhileStatement,
                        'test': {
                            'type': NodeType.UpdateExpression,
                            'operator': '--',
                            'argument': {
                                'type': NodeType.Identifier,
                                'name': 'times'
                            },
                            'prefix': false
                        },
                        'body': {
                            'type': NodeType.BlockStatement,
                            'body': [
                                {
                                    'type': NodeType.IfStatement,
                                    'test': {
                                        'type': NodeType.UnaryExpression,
                                        'operator': '!',
                                        'argument': {
                                            'type': NodeType.Identifier,
                                            'name': 'reverse'
                                        },
                                        'prefix': true
                                    },
                                    'consequent': {
                                        'type': NodeType.BlockStatement,
                                        'body': [
                                            {
                                                'type': NodeType.ExpressionStatement,
                                                'expression': {
                                                    'type': NodeType.AssignmentExpression,
                                                    'operator': '=',
                                                    'left': {
                                                        'type': NodeType.Identifier,
                                                        'name': 'temp'
                                                    },
                                                    'right': {
                                                        'type': NodeType.CallExpression,
                                                        'callee': {
                                                            'type': NodeType.MemberExpression,
                                                            'computed': true,
                                                            'object': {
                                                                'type': NodeType.Identifier,
                                                                'name': 'array'
                                                            },
                                                            'property': {
                                                                'type': NodeType.Literal,
                                                                'name': 'pop',
                                                                'x-verbatim-property': Utils.stringToUnicode('pop')
                                                            }
                                                        },
                                                        'arguments': []
                                                    }
                                                }
                                            },
                                            {
                                                'type': NodeType.ExpressionStatement,
                                                'expression': {
                                                    'type': NodeType.CallExpression,
                                                    'callee': {
                                                        'type': NodeType.MemberExpression,
                                                        'computed': true,
                                                        'object': {
                                                            'type': NodeType.Identifier,
                                                            'name': 'array'
                                                        },
                                                        'property': {
                                                            'type': NodeType.Literal,
                                                            'name': 'unshift',
                                                            'x-verbatim-property': Utils.stringToUnicode('unshift')
                                                        }
                                                    },
                                                    'arguments': [
                                                        {
                                                            'type': NodeType.Identifier,
                                                            'name': 'temp'
                                                        }
                                                    ]
                                                }
                                            }
                                        ]
                                    },
                                    'alternate': {
                                        'type': NodeType.BlockStatement,
                                        'body': [
                                            {
                                                'type': NodeType.ExpressionStatement,
                                                'expression': {
                                                    'type': NodeType.AssignmentExpression,
                                                    'operator': '=',
                                                    'left': {
                                                        'type': NodeType.Identifier,
                                                        'name': 'temp'
                                                    },
                                                    'right': {
                                                        'type': NodeType.CallExpression,
                                                        'callee': {
                                                            'type': NodeType.MemberExpression,
                                                            'computed': true,
                                                            'object': {
                                                                'type': NodeType.Identifier,
                                                                'name': 'array'
                                                            },
                                                            'property': {
                                                                'type': NodeType.Literal,
                                                                'name': 'shift',
                                                                'x-verbatim-property': Utils.stringToUnicode('shift')
                                                            }
                                                        },
                                                        'arguments': []
                                                    }
                                                }
                                            },
                                            {
                                                'type': NodeType.ExpressionStatement,
                                                'expression': {
                                                    'type': NodeType.CallExpression,
                                                    'callee': {
                                                        'type': NodeType.MemberExpression,
                                                        'computed': true,
                                                        'object': {
                                                            'type': NodeType.Identifier,
                                                            'name': 'array'
                                                        },
                                                        'property': {
                                                            'type': NodeType.Literal,
                                                            'name': 'push',
                                                            'x-verbatim-property': Utils.stringToUnicode('push')
                                                        }
                                                    },
                                                    'arguments': [
                                                        {
                                                            'type': NodeType.Identifier,
                                                            'name': 'temp'
                                                        }
                                                    ]
                                                }
                                            }
                                        ]
                                    }
                                }
                            ]
                        }
                    }
                ]
            },
            'generator': false,
            'expression': false
        };
    }
}