javascript-obfuscator 2.18.1 → 3.0.1

package/src/node-transformers/initializing-transformers/CommentsTransformer.ts

@@ -1,173 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-import * as estraverse from '@javascript-obfuscator/estraverse';
-
-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 { ConditionalCommentObfuscatingGuard } from '../preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard';
-import { NodeGuards } from '../../node/NodeGuards';
-
-@injectable()
-export class CommentsTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {string[]}
-     */
-    private static readonly preservedWords: string[] = [
-        '@license',
-        '@preserve'
-    ];
-
-    /**
-     * @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.Initializing:
-                return {
-                    leave: (node: ESTree.Node): ESTree.Node | undefined => {
-                        if (NodeGuards.isProgramNode(node)) {
-                            return this.transformNode(node);
-                        }
-                    }
-                };
-
-            case NodeTransformationStage.Finalizing:
-                return {
-                    leave: (node: ESTree.Node): ESTree.Node | undefined => {
-                        if (NodeGuards.isProgramNode(node)) {
-                            return this.filterCommentsOnFinalizingTraverse(node);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * Moves comments to their nodes
-     */
-    public transformNode (rootNode: ESTree.Program): ESTree.Node {
-        rootNode = this.filterCommentsOnPrimaryTraverse(rootNode);
-
-        if (!rootNode.comments || !rootNode.comments.length) {
-            return rootNode;
-        }
-
-        const comments: ESTree.Comment[] = rootNode.comments.reverse();
-
-        if (comments.length === 0) {
-            return rootNode;
-        }
-
-        if (!rootNode.body.length) {
-            rootNode.leadingComments = comments;
-
-            return rootNode;
-        }
-
-        let isFirstNode: boolean = true;
-
-        estraverse.traverse(rootNode, {
-            enter: (node: ESTree.Node): void => {
-                if (node === rootNode) {
-                    return;
-                }
-
-                const commentIdx: number = comments.findIndex((comment: ESTree.Comment) =>
-                    comment.range && node.range && comment.range[0] < node.range[0]
-                );
-
-                if (commentIdx >= 0) {
-                    (isFirstNode ? rootNode : node).leadingComments =
-                        comments.splice(commentIdx, comments.length - commentIdx).reverse();
-                }
-
-                isFirstNode = false;
-            }
-        });
-
-        if (comments.length > 0) {
-            rootNode.trailingComments = comments.reverse();
-        }
-
-        return rootNode;
-    }
-
-    /**
-     * Removes all comments from node except comments that contain
-     * preserved words or `javascript-obfuscator` words
-     *
-     * @param {ESTree.Program} rootNode
-     * @returns {ESTree.Program}
-     */
-    private filterCommentsOnPrimaryTraverse (rootNode: ESTree.Program): ESTree.Program {
-        rootNode.comments = rootNode.comments?.filter((comment: ESTree.Comment) =>
-            this.filterComment(comment, true)
-        );
-
-        return rootNode;
-    }
-
-    /**
-     * Removes all comments from node except comments that contain preserved words
-     *
-     * @param {ESTree.Program} rootNode
-     * @returns {ESTree.Program}
-     */
-    private filterCommentsOnFinalizingTraverse (rootNode: ESTree.Program): ESTree.Program {
-        estraverse.replace(rootNode, {
-            enter: (node: ESTree.Node): ESTree.Node => {
-                if (node.leadingComments) {
-                    node.leadingComments = node.leadingComments?.filter((comment: ESTree.Comment) =>
-                        this.filterComment(comment, false)
-                    );
-                }
-
-                if (node.trailingComments) {
-                    node.trailingComments = node.trailingComments?.filter((comment: ESTree.Comment) =>
-                        this.filterComment(comment, false)
-                    );
-                }
-
-                return node;
-            }
-        });
-
-        return rootNode;
-    }
-
-    /**
-     * @param {ESTree.Comment} comment
-     * @param {boolean} keepConditionalComment
-     * @returns {boolean}
-     */
-    private filterComment (comment: ESTree.Comment, keepConditionalComment: boolean): boolean {
-        if (keepConditionalComment && ConditionalCommentObfuscatingGuard.isConditionalComment(comment)) {
-            return true;
-        }
-
-        return CommentsTransformer.preservedWords
-            .some((preservedWord: string) => comment.value.includes(preservedWord));
-    }
-}

package/src/node-transformers/preparing-transformers/CustomCodeHelpersTransformer.ts

@@ -1,158 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TCustomCodeHelperGroupStorage } from '../../types/storages/TCustomCodeHelperGroupStorage';
-import { TCustomCodeHelpersGroupAppendMethodName } from '../../types/custom-code-helpers/TCustomCodeHelpersGroupAppendMethodName';
-
-import { ICustomCodeHelperGroup } from '../../interfaces/custom-code-helpers/ICustomCodeHelperGroup';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { ICallsGraphAnalyzer } from '../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphAnalyzer';
-import { ICallsGraphData } from '../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphData';
-import { IPrevailingKindOfVariablesAnalyzer } from '../../interfaces/analyzers/calls-graph-analyzer/IPrevailingKindOfVariablesAnalyzer';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-
-/**
- * Analyzing AST-tree and appending custom code helpers
- */
-@injectable()
-export class CustomCodeHelpersTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {NodeTransformer[]}
-     */
-    public override readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.ParentificationTransformer,
-        NodeTransformer.VariablePreserveTransformer
-    ];
-
-    /**
-     * @type {TCustomCodeHelperGroupStorage}
-     */
-    private readonly customCodeHelperGroupStorage: TCustomCodeHelperGroupStorage;
-
-    /**
-     * @type {ICallsGraphAnalyzer}
-     */
-    private readonly callsGraphAnalyzer: ICallsGraphAnalyzer;
-
-    /**
-     * @type {ICallsGraphData[]}
-     */
-    private callsGraphData: ICallsGraphData[] = [];
-
-    /**
-     * @type {IPrevailingKindOfVariablesAnalyzer}
-     */
-    private readonly prevailingKindOfVariablesAnalyzer: IPrevailingKindOfVariablesAnalyzer;
-
-    /**
-     * @param {ICallsGraphAnalyzer} callsGraphAnalyzer
-     * @param {IPrevailingKindOfVariablesAnalyzer} prevailingKindOfVariablesAnalyzer
-     * @param {TCustomCodeHelperGroupStorage} customCodeHelperGroupStorage
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.ICallsGraphAnalyzer) callsGraphAnalyzer: ICallsGraphAnalyzer,
-        @inject(ServiceIdentifiers.IPrevailingKindOfVariablesAnalyzer)
-            prevailingKindOfVariablesAnalyzer: IPrevailingKindOfVariablesAnalyzer,
-        @inject(ServiceIdentifiers.TCustomNodeGroupStorage) customCodeHelperGroupStorage: TCustomCodeHelperGroupStorage,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-
-        this.callsGraphAnalyzer = callsGraphAnalyzer;
-        this.prevailingKindOfVariablesAnalyzer = prevailingKindOfVariablesAnalyzer;
-        this.customCodeHelperGroupStorage = customCodeHelperGroupStorage;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Preparing:
-                return {
-                    leave: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (NodeGuards.isProgramNode(node)) {
-                            this.prepareNode(node, parentNode);
-                            this.appendCustomNodesForPreparingStage(node, parentNode);
-
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return {
-                    leave: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (NodeGuards.isProgramNode(node)) {
-                            this.appendCustomNodesForStage(nodeTransformationStage, node, parentNode);
-                        }
-
-                        return node;
-                    }
-                };
-        }
-    }
-
-    /**
-     * @param {Program} node
-     * @param {Node | null} parentNode
-     */
-    public prepareNode (node: ESTree.Program, parentNode: ESTree.Node | null): void {
-        this.callsGraphData = this.callsGraphAnalyzer.analyze(node);
-        this.prevailingKindOfVariablesAnalyzer.analyze(node);
-    }
-
-    /**
-     * @param {Program} node
-     * @param {Node | null} parentNode
-     * @returns {Node}
-     */
-    public transformNode (node: ESTree.Program, parentNode: ESTree.Node | null): ESTree.Node {
-        return node;
-    }
-
-    /**
-     * @param {Program} node
-     * @param {Node | null} parentNode
-     */
-    private appendCustomNodesForPreparingStage (node: ESTree.Program, parentNode: ESTree.Node | null): void {
-        this.customCodeHelperGroupStorage
-            .getStorage()
-            .forEach((customCodeHelperGroup: ICustomCodeHelperGroup) => {
-                customCodeHelperGroup.initialize();
-                customCodeHelperGroup.appendOnPreparingStage?.(node, this.callsGraphData);
-            });
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @param {Program} node
-     * @param {Node | null} parentNode
-     */
-    private appendCustomNodesForStage (
-        nodeTransformationStage: NodeTransformationStage,
-        node: ESTree.Program,
-        parentNode: ESTree.Node | null
-    ): void {
-        this.customCodeHelperGroupStorage
-            .getStorage()
-            .forEach((customCodeHelperGroup: ICustomCodeHelperGroup) => {
-                const methodName: TCustomCodeHelpersGroupAppendMethodName = `appendOn${nodeTransformationStage}Stage`;
-
-                customCodeHelperGroup[methodName]?.(node, this.callsGraphData);
-            });
-    }
-}

package/src/node-transformers/preparing-transformers/EvalCallExpressionTransformer.ts

@@ -1,195 +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 { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeUtils } from '../../node/NodeUtils';
-import { StringUtils } from '../../utils/StringUtils';
-
-@injectable()
-export class EvalCallExpressionTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {NodeTransformer[]}
-     */
-    public override readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.EscapeSequenceTransformer,
-        NodeTransformer.ParentificationTransformer,
-        NodeTransformer.VariablePreserveTransformer
-    ];
-
-    /**
-     * @type {Set <FunctionExpression>}
-     */
-    private readonly evalRootAstHostNodeSet: Set <ESTree.FunctionExpression> = new Set();
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @param {Expression | SpreadElement} node
-     * @returns {string | null}
-     */
-    private static extractEvalStringFromCallExpressionArgument (node: ESTree.Expression | ESTree.SpreadElement): string | null {
-        if (NodeGuards.isLiteralNode(node)) {
-            return EvalCallExpressionTransformer
-                .extractEvalStringFromLiteralNode(node);
-        }
-
-        if (NodeGuards.isTemplateLiteralNode(node)) {
-            return EvalCallExpressionTransformer
-                .extractEvalStringFromTemplateLiteralNode(node);
-        }
-
-        return null;
-    }
-
-    /**
-     * @param {Literal} node
-     * @returns {string | null}
-     */
-    private static extractEvalStringFromLiteralNode (node: ESTree.Literal): string | null {
-        return typeof node.value === 'string' ? node.value : null;
-    }
-
-    /**
-     * @param {TemplateLiteral} node
-     * @returns {string | null}
-     */
-    private static extractEvalStringFromTemplateLiteralNode (node: ESTree.TemplateLiteral): string | null {
-        const quasis: ESTree.TemplateElement[] = node.quasis;
-        const allowedQuasisLength: number = 1;
-
-        if (quasis.length !== allowedQuasisLength || node.expressions.length) {
-            return null;
-        }
-
-        return quasis[0].value.cooked ?? null;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Preparing:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (
-                            parentNode
-                            && NodeGuards.isCallExpressionNode(node)
-                            && NodeGuards.isIdentifierNode(node.callee)
-                            && node.callee.name === 'eval'
-                        ) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            case NodeTransformationStage.Finalizing:
-                if (!this.evalRootAstHostNodeSet.size) {
-                    return null;
-                }
-
-                return {
-                    leave: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && this.isEvalRootAstHostNode(node)) {
-                            return this.restoreNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {CallExpression} callExpressionNode
-     * @param {Node} parentNode
-     * @returns {Node}
-     */
-    public transformNode (callExpressionNode: ESTree.CallExpression, parentNode: ESTree.Node): ESTree.Node {
-        const callExpressionFirstArgument: ESTree.Expression | ESTree.SpreadElement | undefined = callExpressionNode.arguments[0];
-
-        if (!callExpressionFirstArgument) {
-            return callExpressionNode;
-        }
-
-        const evalString: string | null = EvalCallExpressionTransformer
-            .extractEvalStringFromCallExpressionArgument(callExpressionFirstArgument);
-
-        if (!evalString) {
-            return callExpressionNode;
-        }
-
-        let ast: ESTree.Statement[];
-
-        // wrapping into try-catch to prevent parsing of incorrect `eval` string
-        try {
-            ast = NodeUtils.convertCodeToStructure(evalString);
-        } catch {
-            return callExpressionNode;
-        }
-
-        /**
-         * we should wrap AST-tree into the parent function expression node (ast root host node).
-         * This function expression node will help to correctly transform AST-tree.
-         */
-        const evalRootAstHostNode: ESTree.FunctionExpression = NodeFactory
-            .functionExpressionNode([], NodeFactory.blockStatementNode(ast));
-
-        NodeUtils.parentizeAst(evalRootAstHostNode);
-        NodeUtils.parentizeNode(evalRootAstHostNode, parentNode);
-
-        /**
-         * we should store that host node and then extract AST-tree on the `finalizing` stage
-         */
-        this.evalRootAstHostNodeSet.add(evalRootAstHostNode);
-
-        return evalRootAstHostNode;
-    }
-
-    /**
-     * @param {FunctionExpression} evalRootAstHostNode
-     * @param {Node} parentNode
-     * @returns {Node}
-     */
-    public restoreNode (evalRootAstHostNode: ESTree.FunctionExpression, parentNode: ESTree.Node): ESTree.Node {
-        const targetAst: ESTree.Statement[] = evalRootAstHostNode.body.body;
-        const obfuscatedCode: string = NodeUtils.convertStructureToCode(targetAst);
-
-        return NodeFactory.callExpressionNode(
-            NodeFactory.identifierNode('eval'),
-            [
-                NodeFactory.literalNode(StringUtils.escapeJsString(obfuscatedCode))
-            ]
-        );
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {boolean}
-     */
-    private isEvalRootAstHostNode (node: ESTree.Node): node is ESTree.FunctionExpression {
-        return NodeGuards.isFunctionExpressionNode(node) && this.evalRootAstHostNodeSet.has(node);
-    }
-}

package/src/node-transformers/preparing-transformers/MetadataTransformer.ts

@@ -1,73 +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 { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeMetadata } from '../../node/NodeMetadata';
-
-/**
- * Adds metadata properties to each node
- */
-@injectable()
-export class MetadataTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {NodeTransformer[]}
-     */
-    public override readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.ParentificationTransformer,
-        NodeTransformer.VariablePreserveTransformer
-    ];
-
-    /**
-     * @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.Preparing:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        return this.transformNode(node, parentNode);
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {Node} node
-     * @param {Node} parentNode
-     * @returns {Node}
-     */
-    public transformNode (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node {
-        NodeMetadata.set(node, { ignoredNode: false });
-
-        if (NodeGuards.isLiteralNode(node)) {
-            NodeMetadata.set(node, { replacedLiteral: false });
-        }
-
-        return node;
-    }
-}