javascript-obfuscator 2.18.1 → 3.0.1

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

@@ -1,121 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TObfuscatingGuardFactory } from '../../types/container/node-transformers/TObfuscatingGuardFactory';
-
-import { IObfuscatingGuard } from '../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
-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 { ObfuscatingGuard } from '../../enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard';
-import { ObfuscatingGuardResult } from '../../enums/node/ObfuscatingGuardResult';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeMetadata } from '../../node/NodeMetadata';
-
-/**
- * Adds `ignoredNode` properties to each node
- */
-@injectable()
-export class ObfuscatingGuardsTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {ObfuscatingGuard[]}
-     */
-    private static readonly obfuscatingGuardsList: ObfuscatingGuard[] = [
-        ObfuscatingGuard.BlackListObfuscatingGuard,
-        ObfuscatingGuard.ConditionalCommentObfuscatingGuard,
-        ObfuscatingGuard.ForceTransformStringObfuscatingGuard,
-        ObfuscatingGuard.IgnoredRequireImportObfuscatingGuard,
-        ObfuscatingGuard.ReservedStringObfuscatingGuard
-    ];
-
-    /**
-     * @type {NodeTransformer[]}
-     */
-    public override readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.ParentificationTransformer,
-        NodeTransformer.VariablePreserveTransformer
-    ];
-
-    /**
-     * @type {IObfuscatingGuard[]}
-     */
-    private readonly obfuscatingGuards: IObfuscatingGuard[];
-
-    /**
-     * @param {TObfuscatingGuardFactory} obfuscatingGuardFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__INodeGuard) obfuscatingGuardFactory: TObfuscatingGuardFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-
-        this.obfuscatingGuards = ObfuscatingGuardsTransformer.obfuscatingGuardsList.map(obfuscatingGuardFactory);
-    }
-
-    /**
-     * @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 {
-        const obfuscatingGuardResults: ObfuscatingGuardResult[] = this.obfuscatingGuards
-            .map((obfuscatingGuard: IObfuscatingGuard) => obfuscatingGuard.check(node));
-
-        this.setNodeMetadata(node, obfuscatingGuardResults);
-
-        return node;
-    }
-
-    /**
-     * @param {Node} node
-     * @param {ObfuscatingGuardResult[]} obfuscatingGuardResults
-     */
-    private setNodeMetadata (node: ESTree.Node, obfuscatingGuardResults: ObfuscatingGuardResult[]): void {
-        const isTransformNode: boolean = obfuscatingGuardResults
-            .every((obfuscatingGuardResult: ObfuscatingGuardResult) => obfuscatingGuardResult === ObfuscatingGuardResult.Transform);
-
-        let isForceTransformNode: boolean = false;
-        let isIgnoredNode: boolean = false;
-
-        if (!isTransformNode) {
-            isForceTransformNode = obfuscatingGuardResults
-                .includes(ObfuscatingGuardResult.ForceTransform);
-            isIgnoredNode = !isForceTransformNode && obfuscatingGuardResults
-                .includes(ObfuscatingGuardResult.Ignore);
-        }
-
-        NodeMetadata.set(node, {
-            forceTransformNode: isForceTransformNode && !NodeGuards.isProgramNode(node),
-            ignoredNode: isIgnoredNode && !NodeGuards.isProgramNode(node)
-        });
-    }
-}

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

@@ -1,57 +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 { NodeUtils } from '../../node/NodeUtils';
-
-/**
- * Adds `parentNode` properties to each node
- */
-@injectable()
-export class ParentificationTransformer 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.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 {
-        return NodeUtils.parentizeNode(node, parentNode);
-    }
-}

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

@@ -1,145 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import * as ESTree from 'estree';
-import * as eslintScope from 'eslint-scope';
-
-import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-
-import { IIdentifierReplacer } from '../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
-import { IScopeIdentifiersTraverserCallbackData } from '../../interfaces/node/IScopeIdentifiersTraverserCallbackData';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-
-/**
- * Preserve non-replaceable variables
- */
-@injectable()
-export class VariablePreserveTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {NodeTransformer.ParentificationTransformer[]}
-     */
-    public override readonly runAfter: NodeTransformer[] = [
-        NodeTransformer.ParentificationTransformer
-    ];
-
-    /**
-     * @type {IIdentifierReplacer}
-     */
-    private readonly identifierReplacer: IIdentifierReplacer;
-
-    /**
-     * @type {IScopeIdentifiersTraverser}
-     */
-    private readonly scopeIdentifiersTraverser: IScopeIdentifiersTraverser;
-
-    /**
-     * @param {IIdentifierReplacer} identifierReplacer
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     * @param {IScopeIdentifiersTraverser} scopeIdentifiersTraverser
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IIdentifierReplacer) identifierReplacer: IIdentifierReplacer,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions,
-        @inject(ServiceIdentifiers.IScopeIdentifiersTraverser) scopeIdentifiersTraverser: IScopeIdentifiersTraverser
-    ) {
-        super(randomGenerator, options);
-
-        this.identifierReplacer = identifierReplacer;
-        this.scopeIdentifiersTraverser = scopeIdentifiersTraverser;
-
-        this.preserveScopeVariableIdentifiers = this.preserveScopeVariableIdentifiers.bind(this);
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Preparing:
-            case NodeTransformationStage.Converting:
-            case NodeTransformationStage.RenameIdentifiers:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isProgramNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {VariableDeclaration} programNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node {
-        this.scopeIdentifiersTraverser.traverseScopeIdentifiers(
-            programNode,
-            parentNode,
-            this.preserveScopeVariableIdentifiers
-        );
-
-        return programNode;
-    }
-
-    /**
-     * @param {IScopeIdentifiersTraverserCallbackData} data
-     */
-    private preserveScopeVariableIdentifiers (data: IScopeIdentifiersTraverserCallbackData): void {
-        const {
-            isGlobalDeclaration,
-            isBubblingDeclaration,
-            variable,
-            variableScope
-        } = data;
-
-        for (const identifier of variable.identifiers) {
-            if (isGlobalDeclaration || isBubblingDeclaration) {
-                this.preserveIdentifierNameForRootLexicalScope(identifier);
-            } else {
-                this.preserveIdentifierNameForLexicalScope(identifier, variableScope);
-            }
-        }
-    }
-
-    /**
-     * @param {Identifier} identifierNode
-     */
-    private preserveIdentifierNameForRootLexicalScope (identifierNode: ESTree.Identifier): void {
-        this.identifierReplacer.preserveName(identifierNode);
-    }
-
-    /**
-     * @param {Identifier} identifierNode
-     * @param {Scope} variableScope
-     */
-    private preserveIdentifierNameForLexicalScope (
-        identifierNode: ESTree.Identifier,
-        variableScope: eslintScope.Scope
-    ): void {
-        const lexicalScopeNode: TNodeWithLexicalScope | null = NodeGuards.isNodeWithLexicalScope(variableScope.block)
-            ? variableScope.block
-            : null;
-
-        if (!lexicalScopeNode) {
-            return;
-        }
-
-        this.identifierReplacer.preserveNameForLexicalScope(identifierNode, lexicalScopeNode);
-    }
-}

package/src/node-transformers/preparing-transformers/obfuscating-guards/BlackListObfuscatingGuard.ts

@@ -1,42 +0,0 @@
-import { injectable } from 'inversify';
-
-import * as ESTree from 'estree';
-
-import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
-
-import { ObfuscatingGuardResult } from '../../../enums/node/ObfuscatingGuardResult';
-
-import { NodeGuards } from '../../../node/NodeGuards';
-
-@injectable()
-export class BlackListObfuscatingGuard implements IObfuscatingGuard {
-    /**
-     * @type {((node: Node) => boolean)[]}
-     */
-    private static readonly blackListGuards: ((node: ESTree.Node) => boolean)[] = [
-        NodeGuards.isDirectiveNode
-    ];
-
-    /**
-     * @type {number}
-     */
-    private readonly blackListGuardsLength: number;
-
-    public constructor () {
-        this.blackListGuardsLength = BlackListObfuscatingGuard.blackListGuards.length;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {ObfuscatingGuardResult}
-     */
-    public check (node: ESTree.Node): ObfuscatingGuardResult {
-        for (let i: number = 0; i < this.blackListGuardsLength; i++) {
-            if (BlackListObfuscatingGuard.blackListGuards[i](node)) {
-                return ObfuscatingGuardResult.Ignore;
-            }
-        }
-
-        return ObfuscatingGuardResult.Transform;
-    }
-}

package/src/node-transformers/preparing-transformers/obfuscating-guards/ConditionalCommentObfuscatingGuard.ts

@@ -1,80 +0,0 @@
-import { injectable } from 'inversify';
-
-import * as ESTree from 'estree';
-
-import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
-
-import { ObfuscatingGuardResult } from '../../../enums/node/ObfuscatingGuardResult';
-
-import { NodeGuards } from '../../../node/NodeGuards';
-
-@injectable()
-export class ConditionalCommentObfuscatingGuard implements IObfuscatingGuard {
-    /**
-     * @type {RegExp}
-     */
-    private static readonly obfuscationEnableCommentRegExp: RegExp = new RegExp('javascript-obfuscator *: *enable');
-
-    /**
-     * @type {RegExp}
-     */
-    private static readonly obfuscationDisableCommentRegExp: RegExp = new RegExp('javascript-obfuscator *: *disable');
-
-    /**
-     * @type {boolean}
-     */
-    private obfuscationAllowed: boolean = true;
-
-    /**
-     * @param {Comment} comment
-     * @returns {boolean}
-     */
-    public static isConditionalComment (comment: ESTree.Comment): boolean {
-        return ConditionalCommentObfuscatingGuard.obfuscationEnableCommentRegExp.test(comment.value) ||
-            ConditionalCommentObfuscatingGuard.obfuscationDisableCommentRegExp.test(comment.value);
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {ObfuscatingGuardResult}
-     */
-    public check (node: ESTree.Node): ObfuscatingGuardResult {
-        if (NodeGuards.isNodeWithComments(node)) {
-            const leadingComments: ESTree.Comment[] | undefined = node.leadingComments;
-
-            if (leadingComments) {
-                this.obfuscationAllowed = this.checkComments(leadingComments);
-            }
-        }
-
-        return this.obfuscationAllowed
-            ? ObfuscatingGuardResult.Transform
-            : ObfuscatingGuardResult.Ignore;
-    }
-
-    /**
-     * @param {Comment[]} comments
-     * @returns {boolean}
-     */
-    private checkComments (comments: ESTree.Comment[]): boolean {
-        const commentsLength: number = comments.length;
-
-        let obfuscationAllowed: boolean = this.obfuscationAllowed;
-
-        for (let i: number = 0; i < commentsLength; i++) {
-            const comment: ESTree.Comment = comments[i];
-
-            if (ConditionalCommentObfuscatingGuard.obfuscationEnableCommentRegExp.test(comment.value)) {
-                obfuscationAllowed = true;
-
-                continue;
-            }
-
-            if (ConditionalCommentObfuscatingGuard.obfuscationDisableCommentRegExp.test(comment.value)) {
-                obfuscationAllowed = false;
-            }
-        }
-
-        return obfuscationAllowed;
-    }
-}

package/src/node-transformers/preparing-transformers/obfuscating-guards/ForceTransformStringObfuscatingGuard.ts

@@ -1,58 +0,0 @@
-import { inject, injectable } from 'inversify';
-
-import * as ESTree from 'estree';
-
-import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
-import { IOptions } from '../../../interfaces/options/IOptions';
-
-import { ObfuscatingGuardResult } from '../../../enums/node/ObfuscatingGuardResult';
-
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import { NodeGuards } from '../../../node/NodeGuards';
-
-@injectable()
-export class ForceTransformStringObfuscatingGuard implements IObfuscatingGuard {
-    /**
-     * @type {IOptions}
-     */
-    private readonly options: IOptions;
-
-    /**
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.options = options;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {ObfuscatingGuardResult}
-     */
-    public check (node: ESTree.Node): ObfuscatingGuardResult {
-        if (
-            this.options.forceTransformStrings.length
-            && NodeGuards.isLiteralNode(node)
-            && typeof node.value === 'string'
-        ) {
-            return !this.isForceTransformString(node.value)
-                ? ObfuscatingGuardResult.Transform
-                : ObfuscatingGuardResult.ForceTransform;
-        }
-
-        return ObfuscatingGuardResult.Transform;
-    }
-
-    /**
-     * @param {string} value
-     * @returns {boolean}
-     */
-    private isForceTransformString (value: string): boolean {
-        return this.options.forceTransformStrings
-            .some((forceTransformString: string) => {
-                return new RegExp(forceTransformString, 'g').exec(value) !== null;
-            });
-    }
-}

package/src/node-transformers/preparing-transformers/obfuscating-guards/IgnoredRequireImportObfuscatingGuard.ts

@@ -1,46 +0,0 @@
-import { inject, injectable } from 'inversify';
-
-import * as ESTree from 'estree';
-
-import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
-import { IOptions } from '../../../interfaces/options/IOptions';
-
-import { ObfuscatingGuardResult } from '../../../enums/node/ObfuscatingGuardResult';
-
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import { NodeGuards } from '../../../node/NodeGuards';
-
-@injectable()
-export class IgnoredRequireImportObfuscatingGuard implements IObfuscatingGuard {
-    /**
-     * @type {IOptions}
-     */
-    private readonly options: IOptions;
-
-    /**
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.options = options;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {ObfuscatingGuardResult}
-     */
-    public check (node: ESTree.Node): ObfuscatingGuardResult {
-        if (
-            this.options.ignoreRequireImports
-            && NodeGuards.isCallExpressionNode(node)
-            && NodeGuards.isIdentifierNode(node.callee)
-            && node.callee.name === 'require'
-        ) {
-            return ObfuscatingGuardResult.Ignore;
-        }
-
-        return ObfuscatingGuardResult.Transform;
-    }
-}

package/src/node-transformers/preparing-transformers/obfuscating-guards/ReservedStringObfuscatingGuard.ts

@@ -1,58 +0,0 @@
-import { inject, injectable } from 'inversify';
-
-import * as ESTree from 'estree';
-
-import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
-import { IOptions } from '../../../interfaces/options/IOptions';
-
-import { ObfuscatingGuardResult } from '../../../enums/node/ObfuscatingGuardResult';
-
-import { ServiceIdentifiers } from '../../../container/ServiceIdentifiers';
-
-import { NodeGuards } from '../../../node/NodeGuards';
-
-@injectable()
-export class ReservedStringObfuscatingGuard implements IObfuscatingGuard {
-    /**
-     * @type {IOptions}
-     */
-    private readonly options: IOptions;
-
-    /**
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.options = options;
-    }
-
-    /**
-     * @param {Node} node
-     * @returns {ObfuscatingGuardResult}
-     */
-    public check (node: ESTree.Node): ObfuscatingGuardResult {
-        if (
-            this.options.reservedStrings.length
-            && NodeGuards.isLiteralNode(node)
-            && typeof node.value === 'string'
-        ) {
-            return !this.isReservedString(node.value)
-                ? ObfuscatingGuardResult.Transform
-                : ObfuscatingGuardResult.Ignore;
-        }
-
-        return ObfuscatingGuardResult.Transform;
-    }
-
-    /**
-     * @param {string} value
-     * @returns {boolean}
-     */
-    private isReservedString (value: string): boolean {
-        return this.options.reservedStrings
-            .some((reservedString: string) => {
-                return new RegExp(reservedString, 'g').exec(value) !== null;
-            });
-    }
-}