javascript-obfuscator 2.18.0 → 3.0.0

package/src/node-transformers/converting-transformers/ClassFieldTransformer.ts

@@ -1,134 +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 { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeGuards } from '../../node/NodeGuards';
-
-/**
- * replaces:
- *     foo () { //... };
- *     foo = 1;
- *
- * or
- *     'foo' () { //... };
- *     'foo' = 1;
- *
- * on:
- *     ['foo'] () { //... };
- *     ['foo'] = 1;
- *
- * Literal node will be obfuscated by LiteralTransformer
- */
-@injectable()
-export class ClassFieldTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {string[]}
-     */
-    private static readonly ignoredNames: string[] = ['constructor'];
-
-    /**
-     * @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.Converting:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (
-                            parentNode
-                            && (
-                                NodeGuards.isMethodDefinitionNode(node)
-                                || NodeGuards.isPropertyDefinitionNode(node)
-                            )
-                        ) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {MethodDefinition | PropertyDefinition} classFieldNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (
-        classFieldNode: ESTree.MethodDefinition | ESTree.PropertyDefinition,
-        parentNode: ESTree.Node
-    ): ESTree.Node {
-        if (NodeGuards.isIdentifierNode(classFieldNode.key)) {
-            return this.replaceIdentifierKey(classFieldNode, classFieldNode.key);
-        }
-
-        if (NodeGuards.isLiteralNode(classFieldNode.key)) {
-            return this.replaceLiteralKey(classFieldNode, classFieldNode.key);
-        }
-
-        return classFieldNode;
-    }
-
-    /**
-     * @param {MethodDefinition | PropertyDefinition} classFieldNode
-     * @param {Identifier} keyNode
-     * @returns {MethodDefinition | PropertyDefinition}
-     */
-    private replaceIdentifierKey (
-        classFieldNode: ESTree.MethodDefinition | ESTree.PropertyDefinition,
-        keyNode: ESTree.Identifier
-    ): ESTree.MethodDefinition | ESTree.PropertyDefinition {
-        if (
-            !ClassFieldTransformer.ignoredNames.includes(keyNode.name)
-            && !classFieldNode.computed
-        ) {
-            classFieldNode.computed = true;
-            classFieldNode.key = NodeFactory.literalNode(keyNode.name);
-        }
-
-        return classFieldNode;
-    }
-
-    /**
-     * @param {MethodDefinition | PropertyDefinition} classFieldNode
-     * @param {Literal} keyNode
-     * @returns {MethodDefinition | PropertyDefinition}
-     */
-    private replaceLiteralKey (
-        classFieldNode: ESTree.MethodDefinition | ESTree.PropertyDefinition,
-        keyNode: ESTree.Literal
-    ): ESTree.MethodDefinition | ESTree.PropertyDefinition {
-        if (
-            typeof keyNode.value === 'string'
-            && !ClassFieldTransformer.ignoredNames.includes(keyNode.value)
-            && !classFieldNode.computed
-        ) {
-            classFieldNode.computed = true;
-        }
-
-        return classFieldNode;
-    }
-}

package/src/node-transformers/converting-transformers/ExportSpecifierTransformer.ts

@@ -1,67 +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 { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeUtils } from '../../node/NodeUtils';
-
-@injectable()
-export class ExportSpecifierTransformer 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.Converting:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isExportSpecifierNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * Replaces:
-     *     export {foo};
-     *
-     * on:
-     *     export {foo as foo};
-     *
-     * @param {ExportSpecifier} exportSpecifierNode
-     * @param {Node} parentNode
-     * @returns {Node}
-     */
-    public transformNode (exportSpecifierNode: ESTree.ExportSpecifier, parentNode: ESTree.Node): ESTree.Node {
-        if (exportSpecifierNode.local.name === exportSpecifierNode.exported.name) {
-            exportSpecifierNode.exported = NodeUtils.clone(exportSpecifierNode.local);
-        }
-
-        return exportSpecifierNode;
-    }
-}

package/src/node-transformers/converting-transformers/MemberExpressionTransformer.ts

@@ -1,77 +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 { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeGuards } from '../../node/NodeGuards';
-
-@injectable()
-export class MemberExpressionTransformer 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.Converting:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isMemberExpressionNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * replaces:
-     *     object.identifier = 1;
-     *
-     * on:
-     *     object['identifier'] = 1;
-     *
-     * and skip:
-     *     object[identifier] = 1;
-     *
-     * Literal node will be obfuscated by StringArrayTransformer
-     *
-     * @param {MemberExpression} memberExpressionNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (memberExpressionNode: ESTree.MemberExpression, parentNode: ESTree.Node): ESTree.Node {
-        if (NodeGuards.isIdentifierNode(memberExpressionNode.property)) {
-            if (memberExpressionNode.computed) {
-                return memberExpressionNode;
-            }
-
-            memberExpressionNode.computed = true;
-            memberExpressionNode.property = NodeFactory.literalNode(memberExpressionNode.property.name);
-        }
-
-        return memberExpressionNode;
-    }
-}

package/src/node-transformers/converting-transformers/NumberLiteralTransformer.ts

@@ -1,102 +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 { NumberUtils } from '../../utils/NumberUtils';
-
-@injectable()
-export class NumberLiteralTransformer extends AbstractNodeTransformer {
-    /**
-     * Have to run it after NumberToNumericalExpressionTransformer to keep logic simple
-     *
-     * @type {NodeTransformer[]}
-     */
-    public override readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.NumberToNumericalExpressionTransformer
-    ];
-
-    /**
-     * @type {Map<ESTree.SimpleLiteral['value'] | ESTree.BigIntLiteral['value'], string>}
-     */
-    private readonly numberLiteralCache: Map <
-        ESTree.SimpleLiteral['value'] | ESTree.BigIntLiteral['value'],
-        string
-    > = new Map();
-
-    /**
-     * @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.Converting:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isLiteralNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * Replaces:
-     *     var foo = 1;
-     *
-     * on:
-     *     var foo = 0x1;
-     *
-     * @param {Literal} literalNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
-        if (typeof literalNode.value !== 'number' && typeof literalNode.value !== 'bigint') {
-            return literalNode;
-        }
-
-        const literalValue: number = <number>literalNode.value;
-
-        let rawValue: string;
-
-        if (this.numberLiteralCache.has(literalValue)) {
-            rawValue = <string>this.numberLiteralCache.get(literalValue);
-        } else {
-            if (NumberUtils.isCeil(literalValue)) {
-                rawValue = NumberUtils.toHex(literalValue);
-            } else {
-                rawValue = String(literalValue);
-            }
-
-            this.numberLiteralCache.set(literalValue, rawValue);
-        }
-
-        return NodeFactory.literalNode(literalValue, rawValue);
-    }
-}

package/src/node-transformers/converting-transformers/NumberToNumericalExpressionTransformer.ts

@@ -1,127 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TNumberNumericalExpressionData } from '../../types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
-
-import { INumberNumericalExpressionAnalyzer } from '../../interfaces/analyzers/number-numerical-expression-analyzer/INumberNumericalExpressionAnalyzer';
-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 { NodeGuards } from '../../node/NodeGuards';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NumberNumericalExpressionAnalyzer } from '../../analyzers/number-numerical-expression-analyzer/NumberNumericalExpressionAnalyzer';
-import { NumberUtils } from '../../utils/NumberUtils';
-import { NumericalExpressionDataToNodeConverter } from '../../node/NumericalExpressionDataToNodeConverter';
-
-/**
- * replaces:
- *     var number = 123;
- *
- * on:
- *     var number = 50 + (100 * 2) - 127;
- */
-@injectable()
-export class NumberToNumericalExpressionTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {INumberNumericalExpressionAnalyzer}
-     */
-    private readonly numberNumericalExpressionAnalyzer: INumberNumericalExpressionAnalyzer;
-
-    /**
-     * @param {INumberNumericalExpressionAnalyzer} numberNumericalExpressionAnalyzer
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.INumberNumericalExpressionAnalyzer)
-            numberNumericalExpressionAnalyzer: INumberNumericalExpressionAnalyzer,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-
-        this.numberNumericalExpressionAnalyzer = numberNumericalExpressionAnalyzer;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        if (!this.options.numbersToExpressions) {
-            return null;
-        }
-
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Converting:
-                return {
-                    leave: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isLiteralNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {Literal} literalNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
-        if (typeof literalNode.value !== 'number') {
-            return literalNode;
-        }
-
-        if (NodeGuards.isPropertyNode(parentNode) && !parentNode.computed) {
-            return literalNode;
-        }
-
-        const baseNumber: number = literalNode.value;
-        const [integerPart, decimalPart] = NumberUtils.extractIntegerAndDecimalParts(baseNumber);
-        const integerNumberNumericalExpressionData: TNumberNumericalExpressionData = this.numberNumericalExpressionAnalyzer
-            .analyze(
-                integerPart,
-                NumberNumericalExpressionAnalyzer.defaultAdditionalPartsCount
-            );
-
-        if (decimalPart) {
-            return NumericalExpressionDataToNodeConverter.convertFloatNumberData(
-                integerNumberNumericalExpressionData,
-                decimalPart,
-                this.getNumberNumericalExpressionLiteralNode
-            );
-        } else {
-            return NumericalExpressionDataToNodeConverter.convertIntegerNumberData(
-                integerNumberNumericalExpressionData,
-                this.getNumberNumericalExpressionLiteralNode
-            );
-        }
-    }
-
-    /**
-     * @param {number} number
-     * @param {boolean} isPositiveNumber
-     * @returns {Expression}
-     */
-    private getNumberNumericalExpressionLiteralNode (number: number, isPositiveNumber: boolean): ESTree.Expression {
-        const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
-
-        return isPositiveNumber
-            ? numberLiteralNode
-            : NodeFactory.unaryExpressionNode(
-                '-',
-                numberLiteralNode
-            );
-    }
-}