javascript-obfuscator 2.18.1 → 3.0.1

package/src/node/NodeMetadata.ts

@@ -1,49 +0,0 @@
-import * as ESTree from 'estree';
-
-export class NodeMetadata {
-    /**
-     * @param {T} node
-     * @param {Partial<T["metadata"]>} metadata
-     */
-    public static set <T extends ESTree.Node = ESTree.Node> (node: T, metadata: Partial<T['metadata']>): void {
-        node.metadata = Object.assign(node.metadata ?? {}, metadata);
-    }
-
-    /**
-     * @param {Node} node
-     * @param {keyof T} metadataKey
-     * @returns {T[keyof T] | undefined}
-     */
-    public static get <
-        T extends ESTree.BaseNodeMetadata,
-        TMetadataKey extends keyof T
-    > (node: ESTree.Node, metadataKey: TMetadataKey): T[TMetadataKey] | undefined {
-        return node.metadata !== undefined
-            ? (<T>node.metadata)[metadataKey]
-            : undefined;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {boolean}
-     */
-    public static isForceTransformNode (node: ESTree.Node): boolean {
-        return NodeMetadata.get<ESTree.BaseNodeMetadata, 'forceTransformNode'>(node, 'forceTransformNode') === true;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {boolean}
-     */
-    public static isIgnoredNode (node: ESTree.Node): boolean {
-        return NodeMetadata.get<ESTree.BaseNodeMetadata, 'ignoredNode'>(node, 'ignoredNode') === true;
-    }
-
-    /**
-     * @param {Node} literalNode
-     * @returns {boolean}
-     */
-    public static isReplacedLiteral (literalNode: ESTree.Literal): boolean {
-        return NodeMetadata.get<ESTree.LiteralNodeMetadata, 'replacedLiteral'>(literalNode, 'replacedLiteral') === true;
-    }
-}

package/src/node/NodeStatementUtils.ts

@@ -1,135 +0,0 @@
-import * as ESTree from 'estree';
-
-import { TNodeWithStatements } from '../types/node/TNodeWithStatements';
-import { TStatement } from '../types/node/TStatement';
-
-import { NodeGuards } from './NodeGuards';
-
-export class NodeStatementUtils {
-    /**
-     * @param {Node} node
-     * @returns {TNodeWithStatements}
-     */
-    public static getParentNodeWithStatements (node: ESTree.Node): TNodeWithStatements {
-        return NodeStatementUtils.getParentNodesWithStatementsRecursive(node, 1)[0];
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {TNodeWithStatements[]}
-     */
-    public static getParentNodesWithStatements (node: ESTree.Node): TNodeWithStatements[] {
-        return NodeStatementUtils.getParentNodesWithStatementsRecursive(node);
-    }
-
-    /**
-     * @param {Statement} statement
-     * @returns {TStatement | null}
-     */
-    public static getNextSiblingStatement (statement: ESTree.Statement): TStatement | null {
-        return NodeStatementUtils.getSiblingStatementByOffset(statement, 1);
-    }
-
-    /**
-     * @param {Statement} statement
-     * @returns {TStatement | null}
-     */
-    public static getPreviousSiblingStatement (statement: ESTree.Statement): TStatement | null {
-        return NodeStatementUtils.getSiblingStatementByOffset(statement, -1);
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {Statement}
-     */
-    public static getRootStatementOfNode (node: ESTree.Node): ESTree.Statement {
-        if (NodeGuards.isProgramNode(node)) {
-            throw new Error('Unable to find root statement for `Program` node');
-        }
-
-        const parentNode: ESTree.Node | undefined = node.parentNode;
-
-        if (!parentNode) {
-            throw new ReferenceError('`parentNode` property of given node is `undefined`');
-        }
-
-        if (!NodeGuards.isNodeWithStatements(parentNode)) {
-            return NodeStatementUtils.getRootStatementOfNode(parentNode);
-        }
-
-        return <ESTree.Statement>node;
-    }
-
-    /**
-     * @param {NodeGuards} node
-     * @returns {TNodeWithStatements}
-     */
-    public static getScopeOfNode (node: ESTree.Node): TNodeWithStatements {
-        const parentNode: ESTree.Node | undefined = node.parentNode;
-
-        if (!parentNode) {
-            throw new ReferenceError('`parentNode` property of given node is `undefined`');
-        }
-
-        if (!NodeGuards.isNodeWithStatements(parentNode)) {
-            return NodeStatementUtils.getScopeOfNode(parentNode);
-        }
-
-        return parentNode;
-    }
-
-    /**
-     * @param {Node} node
-     * @param {number} maxSize
-     * @param {TNodeWithStatements[]} nodesWithStatements
-     * @param {number} depth
-     * @returns {TNodeWithStatements[]}
-     */
-    private static getParentNodesWithStatementsRecursive (
-        node: ESTree.Node,
-        maxSize: number = Infinity,
-        nodesWithStatements: TNodeWithStatements[] = [],
-        depth: number = 0
-    ): TNodeWithStatements[] {
-        if (nodesWithStatements.length >= maxSize) {
-            return nodesWithStatements;
-        }
-
-        const parentNode: ESTree.Node | undefined = node.parentNode;
-
-        if (!parentNode) {
-            throw new ReferenceError('`parentNode` property of given node is `undefined`');
-        }
-
-        if (
-            /**
-             * we can add program node instantly
-             */
-            NodeGuards.isProgramNode(node) ||
-            (NodeGuards.isNodeWithLexicalScopeStatements(node, parentNode) && depth > 0)
-        ) {
-            nodesWithStatements.push(node);
-        }
-
-        if (node !== parentNode) {
-            return NodeStatementUtils.getParentNodesWithStatementsRecursive(parentNode, maxSize, nodesWithStatements, ++depth);
-        }
-
-        return nodesWithStatements;
-    }
-
-    /**
-     * @param {Statement} statement
-     * @param {number} offset
-     * @returns {TStatement | null}
-     */
-    private static getSiblingStatementByOffset (statement: ESTree.Statement, offset: number): TStatement | null {
-        const scopeNode: TNodeWithStatements = NodeStatementUtils.getScopeOfNode(statement);
-        const scopeBody: TStatement[] = !NodeGuards.isSwitchCaseNode(scopeNode)
-            ? scopeNode.body
-            : scopeNode.consequent;
-        const indexInScope: number = scopeBody.indexOf(statement);
-
-        return scopeBody[indexInScope + offset] || null;
-    }
-}

package/src/node/NodeUtils.ts

@@ -1,153 +0,0 @@
-import * as escodegen from '@javascript-obfuscator/escodegen';
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-
-import { ecmaVersion } from '../constants/EcmaVersion';
-
-import { ASTParserFacade } from '../ASTParserFacade';
-import { NodeGuards } from './NodeGuards';
-import { NodeMetadata } from './NodeMetadata';
-
-export class NodeUtils {
-    /**
-     * @param {ESTree.Literal} literalNode
-     * @returns {ESTree.Literal}
-     */
-    public static addXVerbatimPropertyTo (literalNode: ESTree.Literal): ESTree.Literal {
-        literalNode['x-verbatim-property'] = {
-            content: literalNode.raw,
-            precedence: escodegen.Precedence.Primary
-        };
-
-        return literalNode;
-    }
-
-    /**
-     * @param {T} astTree
-     * @returns {T}
-     */
-    public static clone <T extends ESTree.Node = ESTree.Node> (astTree: T): T {
-        return NodeUtils.parentizeAst(NodeUtils.cloneRecursive(astTree));
-    }
-
-    /**
-     * @param {string} code
-     * @returns {ESTree.Statement[]}
-     */
-    public static convertCodeToStructure (code: string): ESTree.Statement[] {
-        const structure: ESTree.Program = ASTParserFacade.parse(
-            code,
-            {
-                ecmaVersion,
-                sourceType: 'script'
-            }
-        );
-
-        estraverse.replace(structure, {
-            enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node => {
-                NodeUtils.parentizeNode(node, parentNode);
-
-                if (NodeGuards.isLiteralNode(node)) {
-                    NodeUtils.addXVerbatimPropertyTo(node);
-                }
-
-                NodeMetadata.set(node, { ignoredNode: false });
-
-                return node;
-            }
-        });
-
-        return <ESTree.Statement[]>structure.body;
-    }
-
-    /**
-     * @param {NodeGuards[]} structure
-     * @returns {string}
-     */
-    public static convertStructureToCode (structure: ESTree.Node[]): string {
-        return structure.reduce((code: string, node: ESTree.Node) => {
-            return code + escodegen.generate(node, {
-                sourceMapWithCode: true
-            }).code;
-        }, '');
-    }
-
-    /**
-     * @param {UnaryExpression} unaryExpressionNode
-     * @returns {NodeGuards}
-     */
-    public static getUnaryExpressionArgumentNode (unaryExpressionNode: ESTree.UnaryExpression): ESTree.Node {
-        if (NodeGuards.isUnaryExpressionNode(unaryExpressionNode.argument)) {
-            return NodeUtils.getUnaryExpressionArgumentNode(unaryExpressionNode.argument);
-        }
-
-        return unaryExpressionNode.argument;
-    }
-
-    /**
-     * @param {T} astTree
-     * @returns {T}
-     */
-    public static parentizeAst <T extends ESTree.Node = ESTree.Node> (astTree: T): T {
-        const parentNode: ESTree.Node | null = astTree.parentNode ?? null;
-
-        estraverse.replace(astTree, {
-            enter: NodeUtils.parentizeNode
-        });
-
-        if (parentNode) {
-            astTree.parentNode = parentNode;
-        }
-
-        return astTree;
-    }
-
-    /**
-     * @param {T} node
-     * @param {Node} parentNode
-     * @returns {T}
-     */
-    public static parentizeNode <T extends ESTree.Node = ESTree.Node> (node: T, parentNode: ESTree.Node | null): T {
-        node.parentNode = parentNode ?? node;
-
-        return node;
-    }
-
-    /**
-     * @param {T} node
-     * @returns {T}
-     */
-    private static cloneRecursive <T> (node: T): T {
-        if (node === null) {
-            return node;
-        }
-
-        const copy: Partial<T> = {};
-        const nodeKeys: (keyof T)[] = <(keyof T)[]>Object.keys(node);
-
-        nodeKeys
-            .forEach((property: keyof T) => {
-                if (property === 'parentNode') {
-                    return;
-                }
-
-                const value: T[keyof T] | T[keyof T][] | null = node[property] ?? null;
-
-                let clonedValue: T[keyof T] | T[keyof T][] | null;
-
-                if (value === null || value instanceof RegExp) {
-                    clonedValue = value;
-                } else if (value instanceof Array) {
-                    clonedValue = value.map(NodeUtils.cloneRecursive);
-                } else if (typeof value === 'object') {
-                    clonedValue = NodeUtils.cloneRecursive(value);
-                } else {
-                    clonedValue = value;
-                }
-
-                copy[property] = <T[keyof T]>clonedValue;
-            });
-
-        return <T>copy;
-    }
-}

package/src/node/NumericalExpressionDataToNodeConverter.ts

@@ -1,155 +0,0 @@
-import * as ESTree from 'estree';
-
-import { TNumericalExpressionDataToNodeConverterLiteralNodeGetter } from '../types/node/TNumericalExpressionDataToNodeConverterLiteralNodeGetter';
-import { TNumberNumericalExpressionData } from '../types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
-
-import { NodeFactory } from './NodeFactory';
-import { NumberUtils } from '../utils/NumberUtils';
-
-/**
- * Converts NumberNumericalExpressionData to node
- */
-export class NumericalExpressionDataToNodeConverter {
-    /**
-     * @param {TNumberNumericalExpressionData} numberNumericalExpressionData
-     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
-     * @returns {Expression}
-     */
-    public static convertIntegerNumberData (
-        numberNumericalExpressionData: TNumberNumericalExpressionData,
-        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
-    ): ESTree.Expression {
-       return NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
-           numberNumericalExpressionData,
-           literalNodeGetter
-       );
-    }
-
-    /**
-     * @param {TNumberNumericalExpressionData} integerNumberNumericalExpressionData
-     * @param {number} decimalPart
-     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
-     * @returns {Expression}
-     */
-    public static convertFloatNumberData (
-        integerNumberNumericalExpressionData: TNumberNumericalExpressionData,
-        decimalPart: number,
-        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
-    ): ESTree.Expression {
-        const integerNumberNumericalExpressionNode: ESTree.Expression = NumericalExpressionDataToNodeConverter
-            .convertNumericalExpressionDataToNode(
-                integerNumberNumericalExpressionData,
-                literalNodeGetter
-            );
-
-        return NodeFactory.binaryExpressionNode(
-            '+',
-            integerNumberNumericalExpressionNode,
-            NodeFactory.literalNode(decimalPart)
-        );
-    }
-
-    /**
-     * @param {TNumberNumericalExpressionData} numberNumericalExpressionData
-     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
-     * @param {BinaryOperator} operator
-     * @returns {Expression}
-     */
-    private static convertNumericalExpressionDataToNode (
-        numberNumericalExpressionData: TNumberNumericalExpressionData,
-        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter,
-        operator: ESTree.BinaryOperator = '+'
-    ): ESTree.Expression {
-        const numberNumericalExpressionDataLength: number = numberNumericalExpressionData.length;
-
-        const leftParts: TNumberNumericalExpressionData = numberNumericalExpressionDataLength > 1
-            ? numberNumericalExpressionData.slice(0, numberNumericalExpressionDataLength - 1)
-            : [numberNumericalExpressionData[0]];
-        const rightParts: TNumberNumericalExpressionData = numberNumericalExpressionDataLength > 1
-            ? numberNumericalExpressionData.slice(-1)
-            : [];
-
-        // trailing iterations
-        if (rightParts.length) {
-            return NumericalExpressionDataToNodeConverter
-                .convertPartsToBinaryExpression(operator, leftParts, rightParts, literalNodeGetter);
-        }
-
-        const firstLeftPartOrNumber: number | number[] | null = leftParts[0] ?? null;
-
-        // last iteration when only single left part is left
-        return Array.isArray(firstLeftPartOrNumber)
-            ? NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
-                firstLeftPartOrNumber,
-                literalNodeGetter,
-                '*'
-            )
-            : NumericalExpressionDataToNodeConverter.convertPartOrNumberToLiteralNode(
-                firstLeftPartOrNumber,
-                literalNodeGetter
-            );
-    }
-
-    /**
-     * @param {BinaryOperator} operator
-     * @param {TNumberNumericalExpressionData} leftParts
-     * @param {TNumberNumericalExpressionData} rightParts
-     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
-     * @returns {BinaryExpression}
-     */
-    private static convertPartsToBinaryExpression (
-        operator: ESTree.BinaryOperator,
-        leftParts: TNumberNumericalExpressionData,
-        rightParts: TNumberNumericalExpressionData,
-        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
-    ): ESTree.BinaryExpression {
-        const rightPartOrNumber: number | number[] = rightParts[0];
-
-        if (Array.isArray(rightPartOrNumber)) {
-            // right part is array with multiply numbers
-            return NodeFactory.binaryExpressionNode(
-                operator,
-                NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
-                    leftParts,
-                    literalNodeGetter
-                ),
-                NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
-                    rightPartOrNumber,
-                    literalNodeGetter,
-                    '*'
-                )
-            );
-        } else {
-            // right part is number
-            return NodeFactory.binaryExpressionNode(
-                operator,
-                NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
-                    leftParts,
-                    literalNodeGetter
-                ),
-                this.convertPartOrNumberToLiteralNode(
-                    rightPartOrNumber,
-                    literalNodeGetter
-                )
-            );
-        }
-    }
-
-    /**
-     * @param {number | number[]} partOrNumber
-     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
-     * @returns {Expression}
-     */
-    private static convertPartOrNumberToLiteralNode (
-        partOrNumber: number | number[],
-        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
-    ): ESTree.Expression {
-        const number: number = Array.isArray(partOrNumber)
-            ? partOrNumber[0]
-            : partOrNumber;
-        const isPositiveNumber: boolean = NumberUtils.isPositive(number);
-        const absoluteNumber: number = Math.abs(number);
-
-        return literalNodeGetter(absoluteNumber, isPositiveNumber);
-    }
-}

package/src/node/ScopeIdentifiersTraverser.ts

@@ -1,163 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import * as eslintScope from 'eslint-scope';
-import * as ESTree from 'estree';
-
-import { TNodeWithLexicalScope } from '../types/node/TNodeWithLexicalScope';
-import { TScopeIdentifiersTraverserCallback } from '../types/node/TScopeIdentifiersTraverserCallback';
-
-import { IScopeAnalyzer } from '../interfaces/analyzers/scope-analyzer/IScopeAnalyzer';
-import { IScopeIdentifiersTraverser } from '../interfaces/node/IScopeIdentifiersTraverser';
-import { IScopeIdentifiersTraverserCallbackData } from '../interfaces/node/IScopeIdentifiersTraverserCallbackData';
-import { IScopeThroughIdentifiersTraverserCallbackData } from '../interfaces/node/IScopeThroughIdentifiersTraverserCallbackData';
-
-import { NodeGuards } from './NodeGuards';
-
-/**
- * Scope traverser
- */
-@injectable()
-export class ScopeIdentifiersTraverser implements IScopeIdentifiersTraverser {
-    /**
-     * @type {string}
-     */
-    private static readonly argumentsVariableName: string = 'arguments';
-
-    /**
-     * @type {string[]}
-     */
-    private static readonly globalScopeNames: string[] = [
-        'global',
-        'module'
-    ];
-
-    /**
-     * @type {IScopeAnalyzer}
-     */
-    private readonly scopeAnalyzer: IScopeAnalyzer;
-
-    /**
-     * @param {IScopeAnalyzer} scopeAnalyzer
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IScopeAnalyzer) scopeAnalyzer: IScopeAnalyzer
-    ) {
-        this.scopeAnalyzer = scopeAnalyzer;
-    }
-
-    /**
-     * @param {Program} programNode
-     * @param {Node | null} parentNode
-     * @param {TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>} callback
-     */
-    public traverseScopeIdentifiers (
-        programNode: ESTree.Program,
-        parentNode: ESTree.Node | null,
-        callback: TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>
-    ): void {
-        this.scopeAnalyzer.analyze(programNode);
-
-        const globalScope: eslintScope.Scope = this.scopeAnalyzer.acquireScope(programNode);
-
-        this.traverseScopeIdentifiersRecursive(globalScope, globalScope, callback);
-    }
-
-    /**
-     * @param {Program} programNode
-     * @param {Node | null} parentNode
-     * @param {TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>} callback
-     */
-    public traverseScopeThroughIdentifiers (
-        programNode: ESTree.Program,
-        parentNode: ESTree.Node | null,
-        callback: TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>
-    ): void {
-        this.scopeAnalyzer.analyze(programNode);
-
-        const globalScope: eslintScope.Scope = this.scopeAnalyzer.acquireScope(programNode);
-
-        this.traverseScopeThroughIdentifiersRecursive(globalScope, globalScope, callback);
-    }
-
-    /**
-     * @param {Scope} rootScope
-     * @param {Scope} currentScope
-     * @param {TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>} callback
-     */
-    private traverseScopeIdentifiersRecursive (
-        rootScope: eslintScope.Scope,
-        currentScope: eslintScope.Scope,
-        callback: TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>
-    ): void {
-        const variableScope: eslintScope.Scope = currentScope.variableScope;
-        const variableLexicalScopeNode: TNodeWithLexicalScope | null = NodeGuards.isNodeWithBlockLexicalScope(variableScope.block)
-            ? variableScope.block
-            : null;
-        const isGlobalDeclaration: boolean = ScopeIdentifiersTraverser.globalScopeNames.includes(variableScope.type);
-
-        if (!variableLexicalScopeNode) {
-            return;
-        }
-
-        for (const variable of currentScope.variables) {
-            if (variable.name === ScopeIdentifiersTraverser.argumentsVariableName) {
-                continue;
-            }
-
-            const isBubblingDeclaration: boolean = variable
-                .identifiers
-                .some((identifier: ESTree.Node) =>
-                    identifier.parentNode
-                    && NodeGuards.isPropertyNode(identifier.parentNode)
-                    && identifier.parentNode.shorthand
-                );
-
-            callback({
-                isGlobalDeclaration,
-                isBubblingDeclaration,
-                rootScope,
-                variable,
-                variableScope,
-                variableLexicalScopeNode
-            });
-        }
-
-        for (const childScope of currentScope.childScopes) {
-            this.traverseScopeIdentifiersRecursive(rootScope, childScope, callback);
-        }
-    }
-
-    /**
-     * @param {Scope} rootScope
-     * @param {Scope} currentScope
-     * @param {TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>} callback
-     */
-    private traverseScopeThroughIdentifiersRecursive (
-        rootScope: eslintScope.Scope,
-        currentScope: eslintScope.Scope,
-        callback: TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>
-    ): void {
-        const variableScope: eslintScope.Scope = currentScope.variableScope;
-        const variableLexicalScopeNode: TNodeWithLexicalScope | null = NodeGuards.isNodeWithBlockLexicalScope(variableScope.block)
-            ? variableScope.block
-            : null;
-        const isGlobalDeclaration: boolean = ScopeIdentifiersTraverser.globalScopeNames.includes(variableScope.type);
-
-        if (!variableLexicalScopeNode) {
-            return;
-        }
-
-        for (const reference of currentScope.through) {
-            callback({
-                isGlobalDeclaration,
-                reference,
-                variableLexicalScopeNode
-            });
-        }
-
-        for (const childScope of currentScope.childScopes) {
-            this.traverseScopeThroughIdentifiersRecursive(rootScope, childScope, callback);
-        }
-    }
-}