anobis/src/node/Nodes.ts

JavaScript obfuscator

import * as escodegen from 'escodegen-wallaby';
import * as ESTree from 'estree';

import { TStatement } from '../types/node/TStatement';

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

export class Nodes {
    /**
     * @param {TStatement[]} body
     * @returns {Program}
     */
    public static getProgramNode (body: TStatement[] = []): ESTree.Program {
        return {
            type: NodeType.Program,
            body,
            sourceType: 'script',
            obfuscatedNode: false
        };
    }

    /**
     * @param {(Expression | SpreadElement)[]} elements
     * @returns {ArrayExpression}
     */
    public static getArrayExpressionNode (
        elements: (ESTree.Expression | ESTree.SpreadElement)[] = []
    ): ESTree.ArrayExpression {
        return {
            type: NodeType.ArrayExpression,
            elements
        };
    }

    /**
     * @param {AssignmentOperator} operator
     * @param {Pattern | MemberExpression} left
     * @param {Expression} right
     * @returns {AssignmentExpression}
     */
    public static getAssignmentExpressionNode (
        operator: ESTree.AssignmentOperator,
        left: ESTree.Pattern | ESTree.MemberExpression,
        right: ESTree.Expression
    ): ESTree.AssignmentExpression {
        return {
            type: NodeType.AssignmentExpression,
            operator,
            left,
            right,
            obfuscatedNode: false
        };
    }

    /**
     * @param {BinaryOperator} operator
     * @param {Expression} left
     * @param {Expression} right
     * @returns {BinaryExpression}
     */
    public static getBinaryExpressionNode (
        operator: ESTree.BinaryOperator,
        left: ESTree.Expression,
        right: ESTree.Expression,
    ): ESTree.BinaryExpression {
        return {
            type: NodeType.BinaryExpression,
            operator,
            left,
            right,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Statement[]} body
     * @returns {BlockStatement}
     */
    public static getBlockStatementNode (body: ESTree.Statement[] = []): ESTree.BlockStatement {
        return {
            type: NodeType.BlockStatement,
            body,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Identifier} label
     * @returns {BreakStatement}
     */
    public static getBreakStatement (label?: ESTree.Identifier): ESTree.BreakStatement {
        const breakStatementNode: ESTree.BreakStatement = {
            type: NodeType.BreakStatement,
            obfuscatedNode: false
        };

        if (label) {
            breakStatementNode.label = label;
        }

        return breakStatementNode;
    }

    /**
     * @param {Statement[]} body
     * @returns {CatchClause}
     */
    public static getCatchClauseNode (body: ESTree.Statement[] = []): ESTree.CatchClause {
        return {
            type: NodeType.CatchClause,
            param: Nodes.getIdentifierNode('err'),
            body: Nodes.getBlockStatementNode(body),
            obfuscatedNode: false
        };
    }

    /**
     * @param {Expression} callee
     * @param {(Expression | SpreadElement)[]} args
     * @returns {CallExpression}
     */
    public static getCallExpressionNode (
        callee: ESTree.Expression,
        args: (ESTree.Expression | ESTree.SpreadElement)[] = []
    ): ESTree.CallExpression {
        return {
            type: NodeType.CallExpression,
            callee,
            arguments: args,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Identifier} label
     * @returns {ContinueStatement}
     */
    public static getContinueStatement (label?: ESTree.Identifier): ESTree.ContinueStatement {
        const continueStatementNode: ESTree.ContinueStatement = {
            type: NodeType.ContinueStatement,
            obfuscatedNode: false
        };

        if (label) {
            continueStatementNode.label = label;
        }

        return continueStatementNode;
    }

    /**
     * @param {Expression} expression
     * @returns {ExpressionStatement}
     */
    public static getExpressionStatementNode (expression: ESTree.Expression): ESTree.ExpressionStatement {
        return {
            type: NodeType.ExpressionStatement,
            expression,
            obfuscatedNode: false
        };
    }

    /**
     * @param {string} functionName
     * @param {Identifier[]} params
     * @param {BlockStatement} body
     * @returns {FunctionDeclaration}
     */
    public static getFunctionDeclarationNode (
        functionName: string,
        params: ESTree.Identifier[],
        body: ESTree.BlockStatement
    ): ESTree.FunctionDeclaration {
        return {
            type: NodeType.FunctionDeclaration,
            id: Nodes.getIdentifierNode(functionName),
            params,
            body,
            generator: false,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Identifier[]} params
     * @param {BlockStatement} body
     * @returns {FunctionExpression}
     */
    public static getFunctionExpressionNode (
        params: ESTree.Identifier[],
        body: ESTree.BlockStatement
    ): ESTree.FunctionExpression {
        return {
            type: NodeType.FunctionExpression,
            params,
            body,
            generator: false,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Expression} test
     * @param {BlockStatement} consequent
     * @param {BlockStatement} alternate
     * @returns {IfStatement}
     */
    public static getIfStatementNode (
        test: ESTree.Expression,
        consequent: ESTree.BlockStatement,
        alternate?: ESTree.BlockStatement
    ): ESTree.IfStatement {
        return {
            type: NodeType.IfStatement,
            test,
            consequent,
            ...alternate && { alternate },
            obfuscatedNode: false
        };
    }

    /**
     * @param {string} name
     * @returns {Identifier}
     */
    public static getIdentifierNode (name: string): ESTree.Identifier {
        return {
            type: NodeType.Identifier,
            name,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Identifier} label
     * @param {Statement} body
     * @returns {LabeledStatement}
     */
    public static getLabeledStatement (label: ESTree.Identifier, body: ESTree.Statement): ESTree.LabeledStatement {
        return {
            type: NodeType.LabeledStatement,
            label,
            body,
            obfuscatedNode: false
        };
    }

    /**
     * @param {boolean | number | string} value
     * @param {string} raw
     * @returns {Literal}
     */
    public static getLiteralNode (value: boolean|number|string, raw?: string): ESTree.Literal {
        raw = raw !== undefined ? raw : `'${value}'`;

        return {
            type: NodeType.Literal,
            value,
            raw,
            'x-verbatim-property': {
                content: raw,
                precedence: escodegen.Precedence.Primary
            },
            obfuscatedNode: false
        };
    }

    /**
     * @param {LogicalOperator} operator
     * @param {Expression} left
     * @param {Expression} right
     * @returns {LogicalExpression}
     */
    public static getLogicalExpressionNode (
        operator: ESTree.LogicalOperator,
        left: ESTree.Expression,
        right: ESTree.Expression,
    ): ESTree.LogicalExpression {
        return {
            type: NodeType.LogicalExpression,
            operator,
            left,
            right,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Expression | Super} object
     * @param {Expression} property
     * @param {boolean} computed
     * @returns {MemberExpression}
     */
    public static getMemberExpressionNode (
        object: ESTree.Expression | ESTree.Super,
        property: ESTree.Expression,
        computed: boolean = false
    ): ESTree.MemberExpression {
        return {
            type: NodeType.MemberExpression,
            computed,
            object,
            property,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Property[]} properties
     * @returns {ObjectExpression}
     */
    public static getObjectExpressionNode (properties: ESTree.Property[]): ESTree.ObjectExpression {
        return {
            type: NodeType.ObjectExpression,
            properties,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Expression} key
     * @param {Expression | Pattern} value
     * @param {boolean} computed
     * @returns {Property}
     */
    public static getPropertyNode (
        key: ESTree.Expression,
        value: ESTree.Expression | ESTree.Pattern,
        computed: boolean = false
    ): ESTree.Property {
        return {
            type: NodeType.Property,
            key,
            value,
            kind: 'init',
            method: false,
            shorthand: false,
            computed,
            obfuscatedNode: false
        };
    }

    /**
     * @param {UnaryOperator} operator
     * @param {Expression} argument
     * @param {boolean} prefix
     * @returns {UnaryExpression}
     */
    public static getUnaryExpressionNode (
        operator: ESTree.UnaryOperator,
        argument: ESTree.Expression,
        prefix: boolean = true
    ): ESTree.UnaryExpression {
        return {
            type: NodeType.UnaryExpression,
            operator,
            argument,
            prefix,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Expression} argument
     * @returns {ReturnStatement}
     */
    public static getReturnStatementNode (argument: ESTree.Expression): ESTree.ReturnStatement {
        return {
            type: NodeType.ReturnStatement,
            argument,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Expression} discriminant
     * @param {SwitchCase[]} cases
     * @returns {SwitchStatement}
     */
    public static getSwitchStatementNode (
        discriminant: ESTree.Expression,
        cases: ESTree.SwitchCase[]
    ): ESTree.SwitchStatement {
        return {
            type: NodeType.SwitchStatement,
            discriminant,
            cases,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Expression} test
     * @param {Statement[]} consequent
     * @returns {SwitchCase}
     */
    public static getSwitchCaseNode (test: ESTree.Expression, consequent: ESTree.Statement[]): ESTree.SwitchCase {
        return {
            type: NodeType.SwitchCase,
            test,
            consequent,
            obfuscatedNode: false
        };
    }

    /**
     * @param {UpdateOperator} operator
     * @param {Expression} argumentExpr
     * @returns {UpdateExpression}
     */
    public static getUpdateExpressionNode (operator: ESTree.UpdateOperator, argumentExpr: ESTree.Expression): ESTree.UpdateExpression {
        return {
            type: NodeType.UpdateExpression,
            operator,
            argument: argumentExpr,
            prefix: false,
            obfuscatedNode: false
        };
    }

    /**
     * @param {VariableDeclarator[]} declarations
     * @param {string} kind
     * @returns {VariableDeclaration}
     */
    public static getVariableDeclarationNode (
        declarations: ESTree.VariableDeclarator[] = [],
        kind: 'var' | 'let' | 'const' = 'var'
    ): ESTree.VariableDeclaration {
        return {
            type: NodeType.VariableDeclaration,
            declarations,
            kind,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Identifier} id
     * @param {any} init
     * @returns {VariableDeclarator}
     */
    public static getVariableDeclaratorNode (id: ESTree.Identifier, init: any): ESTree.VariableDeclarator {
        return {
            type: NodeType.VariableDeclarator,
            id,
            init,
            obfuscatedNode: false
        };
    }

    /**
     * @param {Expression} test
     * @param {Statement} body
     * @returns {WhileStatement}
     */
    public static getWhileStatementNode (test: ESTree.Expression, body: ESTree.Statement): ESTree.WhileStatement {
        return {
            type: NodeType.WhileStatement,
            test,
            body,
            obfuscatedNode: false
        };
    }
}