javascript-obfuscator 2.18.0 → 3.0.0

package/src/node-transformers/simplifying-transformers/AbstractStatementSimplifyTransformer.ts

@@ -1,196 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { IIteratedStatementsSimplifyData } from '../../interfaces/node-transformers/simplifying-transformers/IIteratedStatementsSimplifyData';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IStatementSimplifyData } from '../../interfaces/node-transformers/simplifying-transformers/IStatementSimplifyData';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeFactory } from '../../node/NodeFactory';
-
-/**
- * Simplifies `Statement` node
- */
-@injectable()
-export abstract class AbstractStatementSimplifyTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {NodeTransformer[]}
-     */
-    public override readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.ExpressionStatementsMergeTransformer,
-        NodeTransformer.VariableDeclarationsMergeTransformer
-    ];
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    protected constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * Returns IStatementSimplifyData based on `Statement` node
-     *
-     * @param {ESTree.Statement | null | undefined} statementNode
-     * @returns {IStatementSimplifyData | null}
-     */
-    protected getStatementSimplifyData (
-        statementNode: ESTree.Statement | null | undefined
-    ): IStatementSimplifyData | null {
-        if (!statementNode) {
-            return null;
-        }
-
-        if (!NodeGuards.isBlockStatementNode(statementNode)) {
-            return {
-                leadingStatements: [statementNode],
-                trailingStatement: null,
-                hasReturnStatement: false,
-                hasSingleExpression: false
-            };
-        }
-
-        const {
-            startIndex,
-            unwrappedExpressions,
-            hasReturnStatement
-        } = this.collectIteratedStatementsSimplifyData(statementNode);
-
-        const leadingStatements: ESTree.Statement[] = this.getLeadingStatements(statementNode, startIndex);
-
-        if (!unwrappedExpressions.length) {
-            return {
-                leadingStatements,
-                trailingStatement: null,
-                hasReturnStatement,
-                hasSingleExpression: false
-            };
-        }
-
-        const hasSingleExpression: boolean = unwrappedExpressions.length === 1;
-
-        const expression: ESTree.Expression = hasSingleExpression
-            ? unwrappedExpressions[0]
-            : NodeFactory.sequenceExpressionNode(unwrappedExpressions);
-
-        const statement: ESTree.Statement = hasReturnStatement
-            ? NodeFactory.returnStatementNode(expression)
-            : NodeFactory.expressionStatementNode(expression);
-
-        return {
-            leadingStatements,
-            trailingStatement: {
-                statement,
-                expression
-            },
-            hasReturnStatement,
-            hasSingleExpression
-        };
-    }
-
-    /**
-     * Iterates over `BlockStatement` node body and collects data
-     *
-     * @param {ESTree.Statement | null | undefined} statementNode
-     * @returns {IIteratedStatementsSimplifyData}
-     */
-    protected collectIteratedStatementsSimplifyData (
-        statementNode: ESTree.BlockStatement
-    ): IIteratedStatementsSimplifyData {
-        const statementNodeBodyLength: number = statementNode.body.length;
-        const unwrappedExpressions: ESTree.Expression[] = [];
-
-        let hasReturnStatement: boolean = false;
-        let startIndex: number | null = null;
-
-        for (let i = statementNodeBodyLength - 1; i >= 0; i--) {
-            const statementBodyStatementNode: ESTree.Statement = statementNode.body[i];
-
-            if (NodeGuards.isExpressionStatementNode(statementBodyStatementNode)) {
-                if (NodeGuards.isSequenceExpressionNode(statementBodyStatementNode.expression)) {
-                    unwrappedExpressions.unshift(...statementBodyStatementNode.expression.expressions);
-                } else {
-                    unwrappedExpressions.unshift(statementBodyStatementNode.expression);
-                }
-
-                startIndex = i;
-                continue;
-            }
-
-            if (
-                NodeGuards.isReturnStatementNode(statementBodyStatementNode)
-                && statementBodyStatementNode.argument
-            ) {
-                unwrappedExpressions.unshift(statementBodyStatementNode.argument);
-                hasReturnStatement = true;
-                startIndex = i;
-                continue;
-            }
-
-            break;
-        }
-
-        return {
-            startIndex,
-            unwrappedExpressions,
-            hasReturnStatement
-        };
-    }
-
-    /**
-     * Returns leading statements
-     *
-     * @param {ESTree.BlockStatement} statementNode
-     * @param {number | null} startIndex
-     * @returns {ESTree.Statement[]}
-     */
-    protected getLeadingStatements (statementNode: ESTree.BlockStatement, startIndex: number | null): ESTree.Statement[] {
-        // variant #1: no valid statements inside `BlockStatement` are found
-        if (startIndex === null) {
-            return statementNode.body;
-        }
-
-        return startIndex === 0
-            // variant #2: all statements inside `BlockStatement` branch are valid
-            ? []
-            // variant #3: only last N statements inside `BlockStatement` branch are valid
-            : statementNode.body.slice(0, startIndex);
-    }
-
-    /**
-     * @param {IStatementSimplifyData} statementSimplifyData
-     * @returns {ESTree.Statement}
-     */
-    protected getPartialStatement (statementSimplifyData: IStatementSimplifyData): ESTree.Statement {
-        // variant #1: all statements inside `BlockStatement` branch are valid
-        if (!statementSimplifyData.leadingStatements.length && statementSimplifyData.trailingStatement) {
-            return statementSimplifyData.trailingStatement.statement;
-        }
-
-        // variant #2: only last N statements inside `BlockStatement` branch are valid
-        return NodeFactory.blockStatementNode([
-            ...statementSimplifyData.leadingStatements.length ? statementSimplifyData.leadingStatements : [],
-            ...statementSimplifyData.trailingStatement ? [statementSimplifyData.trailingStatement.statement] : []
-        ]);
-    }
-
-    /**
-     * @param {ESTree.Statement} statementNode
-     * @param {ESTree.Node} parentNode
-     * @returns {ESTree.Node}
-     */
-    public abstract override transformNode (
-        statementNode: ESTree.Statement,
-        parentNode: ESTree.Node
-    ): ESTree.Node;
-}

package/src/node-transformers/simplifying-transformers/BlockStatementSimplifyTransformer.ts

@@ -1,87 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IStatementSimplifyData } from '../../interfaces/node-transformers/simplifying-transformers/IStatementSimplifyData';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractStatementSimplifyTransformer } from './AbstractStatementSimplifyTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeUtils } from '../../node/NodeUtils';
-
-/**
- * Simplifies `BlockStatement` node
- */
-@injectable()
-export class BlockStatementSimplifyTransformer extends AbstractStatementSimplifyTransformer {
-    /**
-     * @type {NodeTransformer[]}
-     */
-    public override readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.VariableDeclarationsMergeTransformer
-    ];
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Simplifying:
-                return {
-                    leave: (
-                        node: ESTree.Node,
-                        parentNode: ESTree.Node | null
-                    ): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isBlockStatementNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {ESTree.Statement} statementNode
-     * @param {ESTree.Node} parentNode
-     * @returns {ESTree.Node}
-     */
-    public transformNode (
-        statementNode: ESTree.Statement,
-        parentNode: ESTree.Node
-    ): ESTree.Node {
-        const simplifyData: IStatementSimplifyData | null = this.getStatementSimplifyData(statementNode);
-
-        if (!simplifyData) {
-            return statementNode;
-        }
-
-        const partialStatementNode: ESTree.Statement = this.getPartialStatement(simplifyData);
-        const transformedNode: ESTree.Node = NodeGuards.isBlockStatementNode(partialStatementNode)
-            ? partialStatementNode
-            : NodeFactory.blockStatementNode([partialStatementNode]);
-
-        return NodeUtils.parentizeNode(transformedNode, parentNode);
-    }
-}

package/src/node-transformers/simplifying-transformers/ExpressionStatementsMergeTransformer.ts

@@ -1,99 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-
-import { TStatement } from '../../types/node/TStatement';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeStatementUtils } from '../../node/NodeStatementUtils';
-import { NodeUtils } from '../../node/NodeUtils';
-
-/**
- * replaces:
- *     console.log(1);
- *     console.log(2);
- *
- * on:
- *     (console.log(1), console.log(2));
- */
-@injectable()
-export class ExpressionStatementsMergeTransformer extends AbstractNodeTransformer {
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Simplifying:
-                return {
-                    leave: (
-                        node: ESTree.Node,
-                        parentNode: ESTree.Node | null
-                    ): ESTree.Node | estraverse.VisitorOption | undefined => {
-                        if (parentNode && NodeGuards.isExpressionStatementNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {ESTree.ExpressionStatement} expressionStatementNode
-     * @param {ESTree.Node} parentNode
-     * @returns {ESTree.ExpressionStatement | estraverse.VisitorOption}
-     */
-    public transformNode (
-        expressionStatementNode: ESTree.ExpressionStatement,
-        parentNode: ESTree.Node
-    ): ESTree.ExpressionStatement | estraverse.VisitorOption {
-        if (!NodeGuards.isNodeWithStatements(parentNode)) {
-            return expressionStatementNode;
-        }
-
-        const prevStatement: TStatement | null = NodeStatementUtils.getPreviousSiblingStatement(expressionStatementNode);
-
-        if (!prevStatement || !NodeGuards.isExpressionStatementNode(prevStatement)) {
-            return expressionStatementNode;
-        }
-
-        if (NodeGuards.isSequenceExpressionNode(prevStatement.expression)) {
-            prevStatement.expression.expressions.push(expressionStatementNode.expression);
-            NodeUtils.parentizeNode(expressionStatementNode.expression, prevStatement.expression);
-        } else {
-            prevStatement.expression = NodeFactory.sequenceExpressionNode([
-                prevStatement.expression,
-                expressionStatementNode.expression
-            ]);
-
-            NodeUtils.parentizeAst(prevStatement.expression);
-            NodeUtils.parentizeNode(prevStatement.expression, prevStatement);
-        }
-
-        return estraverse.VisitorOption.Remove;
-    }
-}