javascript-obfuscator 2.18.1 → 3.0.1

package/src/ASTParserFacade.ts

@@ -1,119 +0,0 @@
-import * as acorn from 'acorn';
-import * as ESTree from 'estree';
-import chalk, { Chalk } from 'chalk';
-
-/**
- * Facade over AST parser `acorn`
- */
-export class ASTParserFacade {
-    /**
-     * @type {Chalk}
-     */
-    private static readonly colorError: Chalk = chalk.red;
-
-    /**
-     * @type {number}
-     */
-    private static readonly nearestSymbolsCount: number = 15;
-
-    /**
-     * @type {acorn.Options['sourceType'][]}
-     */
-    private static readonly sourceTypes: acorn.Options['sourceType'][] = [
-        'script',
-        'module'
-    ];
-
-    /**
-     * @param {string} sourceCode
-     * @param {Options} config
-     * @returns {Program}
-     */
-    public static parse (sourceCode: string, config: acorn.Options): ESTree.Program | never {
-        const sourceTypeLength: number = ASTParserFacade.sourceTypes.length;
-
-        for (let i: number = 0; i < sourceTypeLength; i++) {
-            try {
-                return ASTParserFacade.parseType(sourceCode, config, ASTParserFacade.sourceTypes[i]);
-            } catch (error) {
-                if (i < sourceTypeLength - 1) {
-                    continue;
-                }
-
-                throw new Error(ASTParserFacade.processParsingError(
-                    sourceCode,
-                    error.message,
-                    error.loc
-                ));
-            }
-        }
-
-        throw new Error('Acorn parsing error');
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @param {acorn.Options} inputConfig
-     * @param {acorn.Options["sourceType"]} sourceType
-     * @returns {Program}
-     */
-    private static parseType (
-        sourceCode: string,
-        inputConfig: acorn.Options,
-        sourceType: acorn.Options['sourceType']
-    ): ESTree.Program {
-        const comments: ESTree.Comment[] = [];
-        const config: acorn.Options = {
-            ...inputConfig,
-            allowAwaitOutsideFunction: true,
-            onComment: comments,
-            sourceType
-        };
-
-        const program: acorn.Node & ESTree.Program = <acorn.Node & ESTree.Program>acorn
-            .parse(sourceCode, config);
-
-        if (comments.length) {
-            program.comments = comments;
-        }
-
-        return program;
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @param {string} errorMessage
-     * @param {Position | null} position
-     * @returns {never}
-     */
-    private static processParsingError (
-        sourceCode: string,
-        errorMessage: string,
-        position: ESTree.Position | null
-    ): never {
-        const isMissingLocationData = !position || !position.line || !position.column;
-
-        if (isMissingLocationData) {
-            throw new Error(errorMessage);
-        }
-
-        const sourceCodeLines: string[] = sourceCode.split(/\r?\n/);
-        const errorLine: string | undefined = sourceCodeLines[position.line - 1];
-
-        if (!errorLine) {
-            throw new Error(errorMessage);
-        }
-
-        const startErrorIndex: number = Math.max(0, position.column - ASTParserFacade.nearestSymbolsCount);
-        const endErrorIndex: number = Math.min(errorLine.length, position.column + ASTParserFacade.nearestSymbolsCount);
-
-        const formattedPointer: string = ASTParserFacade.colorError('>');
-        const formattedCodeSlice: string = `...${
-            errorLine.slice(startErrorIndex, endErrorIndex).replace(/^\s+/, '')
-        }...`;
-
-        throw new Error(
-            `ERROR at line ${position.line}: ${errorMessage}\n${formattedPointer} ${formattedCodeSlice}`
-        );
-    }
-}

package/src/JavaScriptObfuscator.ts

@@ -1,311 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from './container/ServiceIdentifiers';
-
-import * as acorn from 'acorn';
-import * as escodegen from '@javascript-obfuscator/escodegen';
-import * as ESTree from 'estree';
-
-import { TObfuscationResultFactory } from './types/container/source-code/TObfuscationResultFactory';
-
-import { ICodeTransformersRunner } from './interfaces/code-transformers/ICodeTransformersRunner';
-import { IGeneratorOutput } from './interfaces/IGeneratorOutput';
-import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
-import { ILogger } from './interfaces/logger/ILogger';
-import { IObfuscationResult } from './interfaces/source-code/IObfuscationResult';
-import { IOptions } from './interfaces/options/IOptions';
-import { IRandomGenerator } from './interfaces/utils/IRandomGenerator';
-import { INodeTransformersRunner } from './interfaces/node-transformers/INodeTransformersRunner';
-
-import { CodeTransformer } from './enums/code-transformers/CodeTransformer';
-import { CodeTransformationStage } from './enums/code-transformers/CodeTransformationStage';
-import { LoggingMessage } from './enums/logger/LoggingMessage';
-import { NodeTransformer } from './enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from './enums/node-transformers/NodeTransformationStage';
-
-import { ecmaVersion } from './constants/EcmaVersion';
-
-import { ASTParserFacade } from './ASTParserFacade';
-import { NodeGuards } from './node/NodeGuards';
-import { Utils } from './utils/Utils';
-import { SourceMapSourcesMode } from './enums/source-map/SourceMapSourcesMode';
-
-@injectable()
-export class JavaScriptObfuscator implements IJavaScriptObfuscator {
-    /**
-     * @type {Options}
-     */
-    private static readonly parseOptions: acorn.Options = {
-        ecmaVersion,
-        allowHashBang: true,
-        allowImportExportEverywhere: true,
-        allowReturnOutsideFunction: true,
-        locations: true,
-        ranges: true
-    };
-
-    /**
-     * @type {GenerateOptions}
-     */
-    private static readonly escodegenParams: escodegen.GenerateOptions = {
-        comment: true,
-        verbatim: 'x-verbatim-property',
-        sourceMapWithCode: true
-    };
-
-    /**
-     * @type {CodeTransformer[]}
-     */
-    private static readonly codeTransformersList: CodeTransformer[] = [
-        CodeTransformer.HashbangOperatorTransformer
-    ];
-
-    /**
-     * @type {NodeTransformer[]}
-     */
-    private static readonly nodeTransformersList: NodeTransformer[] = [
-        NodeTransformer.BooleanLiteralTransformer,
-        NodeTransformer.BlockStatementControlFlowTransformer,
-        NodeTransformer.BlockStatementSimplifyTransformer,
-        NodeTransformer.ClassFieldTransformer,
-        NodeTransformer.CommentsTransformer,
-        NodeTransformer.CustomCodeHelpersTransformer,
-        NodeTransformer.DeadCodeInjectionTransformer,
-        NodeTransformer.EscapeSequenceTransformer,
-        NodeTransformer.EvalCallExpressionTransformer,
-        NodeTransformer.ExportSpecifierTransformer,
-        NodeTransformer.ExpressionStatementsMergeTransformer,
-        NodeTransformer.FunctionControlFlowTransformer,
-        NodeTransformer.IfStatementSimplifyTransformer,
-        NodeTransformer.LabeledStatementTransformer,
-        NodeTransformer.RenamePropertiesTransformer,
-        NodeTransformer.MemberExpressionTransformer,
-        NodeTransformer.MetadataTransformer,
-        NodeTransformer.NumberLiteralTransformer,
-        NodeTransformer.NumberToNumericalExpressionTransformer,
-        NodeTransformer.ObfuscatingGuardsTransformer,
-        NodeTransformer.ObjectExpressionKeysTransformer,
-        NodeTransformer.ObjectExpressionTransformer,
-        NodeTransformer.ObjectPatternPropertiesTransformer,
-        NodeTransformer.ParentificationTransformer,
-        NodeTransformer.ScopeIdentifiersTransformer,
-        NodeTransformer.ScopeThroughIdentifiersTransformer,
-        NodeTransformer.SplitStringTransformer,
-        NodeTransformer.StringArrayRotateFunctionTransformer,
-        NodeTransformer.StringArrayScopeCallsWrapperTransformer,
-        NodeTransformer.StringArrayTransformer,
-        NodeTransformer.TemplateLiteralTransformer,
-        NodeTransformer.DirectivePlacementTransformer,
-        NodeTransformer.VariableDeclarationsMergeTransformer,
-        NodeTransformer.VariablePreserveTransformer
-    ];
-
-    /**
-     * @type {ICodeTransformersRunner}
-     */
-    private readonly codeTransformersRunner: ICodeTransformersRunner;
-
-    /**
-     * @type {ILogger}
-     */
-    private readonly logger: ILogger;
-
-    /**
-     * @type {TObfuscationResultFactory}
-     */
-    private readonly obfuscationResultFactory: TObfuscationResultFactory;
-
-    /**
-     * @type {IOptions}
-     */
-    private readonly options: IOptions;
-
-    /**
-     * @type {IRandomGenerator}
-     */
-    private readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @type {INodeTransformersRunner}
-     */
-    private readonly nodeTransformersRunner: INodeTransformersRunner;
-
-    /**
-     * @param {ICodeTransformersRunner} codeTransformersRunner
-     * @param {INodeTransformersRunner} nodeTransformersRunner
-     * @param {IRandomGenerator} randomGenerator
-     * @param {TObfuscationResultFactory} obfuscatedCodeFactory
-     * @param {ILogger} logger
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.ICodeTransformersRunner) codeTransformersRunner: ICodeTransformersRunner,
-        @inject(ServiceIdentifiers.INodeTransformersRunner) nodeTransformersRunner: INodeTransformersRunner,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.Factory__IObfuscationResult) obfuscatedCodeFactory: TObfuscationResultFactory,
-        @inject(ServiceIdentifiers.ILogger) logger: ILogger,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.codeTransformersRunner = codeTransformersRunner;
-        this.nodeTransformersRunner = nodeTransformersRunner;
-        this.randomGenerator = randomGenerator;
-        this.obfuscationResultFactory = obfuscatedCodeFactory;
-        this.logger = logger;
-        this.options = options;
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @returns {IObfuscationResult}
-     */
-    public obfuscate (sourceCode: string): IObfuscationResult {
-        if (typeof sourceCode !== 'string') {
-            sourceCode = '';
-        }
-
-        const timeStart: number = Date.now();
-        this.logger.info(LoggingMessage.Version, Utils.buildVersionMessage(process.env.VERSION, process.env.BUILD_TIMESTAMP));
-        this.logger.info(LoggingMessage.ObfuscationStarted);
-        this.logger.info(LoggingMessage.RandomGeneratorSeed, this.randomGenerator.getInputSeed());
-
-        // preparing code transformations
-        sourceCode = this.runCodeTransformationStage(sourceCode, CodeTransformationStage.PreparingTransformers);
-
-        // parse AST tree
-        const astTree: ESTree.Program = this.parseCode(sourceCode);
-
-        // obfuscate AST tree
-        const obfuscatedAstTree: ESTree.Program = this.transformAstTree(astTree);
-
-        // generate code
-        const generatorOutput: IGeneratorOutput = this.generateCode(sourceCode, obfuscatedAstTree);
-
-        // finalizing code transformations
-        generatorOutput.code = this.runCodeTransformationStage(generatorOutput.code, CodeTransformationStage.FinalizingTransformers);
-
-        const obfuscationTime: number = (Date.now() - timeStart) / 1000;
-        this.logger.success(LoggingMessage.ObfuscationCompleted, obfuscationTime);
-
-        return this.getObfuscationResult(generatorOutput);
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @returns {Program}
-     */
-    private parseCode (sourceCode: string): ESTree.Program {
-        return ASTParserFacade.parse(sourceCode, JavaScriptObfuscator.parseOptions);
-    }
-
-    /**
-     * @param {Program} astTree
-     * @returns {Program}
-     */
-    private transformAstTree (astTree: ESTree.Program): ESTree.Program {
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Initializing);
-
-        const isEmptyAstTree: boolean = NodeGuards.isProgramNode(astTree)
-            && !astTree.body.length
-            && !astTree.leadingComments
-            && !astTree.trailingComments;
-
-        if (isEmptyAstTree) {
-            this.logger.warn(LoggingMessage.EmptySourceCode);
-
-            return astTree;
-        }
-
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Preparing);
-
-        if (this.options.deadCodeInjection) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.DeadCodeInjection);
-        }
-
-        if (this.options.controlFlowFlattening) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.ControlFlowFlattening);
-        }
-
-        if (this.options.renameProperties) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.RenameProperties);
-        }
-
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Converting);
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.RenameIdentifiers);
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.StringArray);
-
-        if (this.options.simplify) {
-            astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Simplifying);
-        }
-
-        astTree = this.runNodeTransformationStage(astTree, NodeTransformationStage.Finalizing);
-
-        return astTree;
-    }
-
-    /**
-     * @param {string} sourceCode
-     * @param {Program} astTree
-     * @returns {IGeneratorOutput}
-     */
-    private generateCode (sourceCode: string, astTree: ESTree.Program): IGeneratorOutput {
-        const escodegenParams: escodegen.GenerateOptions = {
-            ...JavaScriptObfuscator.escodegenParams,
-            format: {
-                compact: this.options.compact
-            },
-            ...this.options.sourceMap && {
-                ...this.options.sourceMapSourcesMode === SourceMapSourcesMode.SourcesContent
-                    ? {
-                        sourceMap: 'sourceMap',
-                        sourceContent: sourceCode
-                    }
-                    : {
-                        sourceMap: this.options.inputFileName || 'sourceMap'
-                    }
-            }
-        };
-
-        const generatorOutput: IGeneratorOutput = escodegen.generate(astTree, escodegenParams);
-
-        generatorOutput.map = generatorOutput.map ? generatorOutput.map.toString() : '';
-
-        return generatorOutput;
-    }
-
-    /**
-     * @param {IGeneratorOutput} generatorOutput
-     * @returns {IObfuscationResult}
-     */
-    private getObfuscationResult (generatorOutput: IGeneratorOutput): IObfuscationResult {
-        return this.obfuscationResultFactory(generatorOutput.code, generatorOutput.map);
-    }
-
-    /**
-     * @param {string} code
-     * @param {CodeTransformationStage} codeTransformationStage
-     * @returns {string}
-     */
-    private runCodeTransformationStage (code: string, codeTransformationStage: CodeTransformationStage): string {
-        this.logger.info(LoggingMessage.CodeTransformationStage, codeTransformationStage);
-
-        return this.codeTransformersRunner.transform(
-            code,
-            JavaScriptObfuscator.codeTransformersList,
-            codeTransformationStage
-        );
-    }
-
-    /**
-     * @param {Program} astTree
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {Program}
-     */
-    private runNodeTransformationStage (astTree: ESTree.Program, nodeTransformationStage: NodeTransformationStage): ESTree.Program {
-        this.logger.info(LoggingMessage.NodeTransformationStage, nodeTransformationStage);
-
-        return this.nodeTransformersRunner.transform(
-            astTree,
-            JavaScriptObfuscator.nodeTransformersList,
-            nodeTransformationStage
-        );
-    }
-}

package/src/JavaScriptObfuscatorCLIFacade.ts

@@ -1,17 +0,0 @@
-import 'reflect-metadata';
-
-import { JavaScriptObfuscatorCLI } from './cli/JavaScriptObfuscatorCLI';
-
-class JavaScriptObfuscatorCLIFacade {
-    /**
-     * @param {string[]} argv
-     */
-    public static obfuscate (argv: string[]): void {
-        const javaScriptObfuscatorCLI: JavaScriptObfuscatorCLI = new JavaScriptObfuscatorCLI(argv);
-
-        javaScriptObfuscatorCLI.initialize();
-        javaScriptObfuscatorCLI.run();
-    }
-}
-
-export { JavaScriptObfuscatorCLIFacade as JavaScriptObfuscatorCLI };

package/src/JavaScriptObfuscatorFacade.ts

@@ -1,93 +0,0 @@
-import 'reflect-metadata';
-
-import { ServiceIdentifiers } from './container/ServiceIdentifiers';
-
-import { TDictionary } from './types/TDictionary';
-import { TInputOptions } from './types/options/TInputOptions';
-import { TObfuscationResultsObject } from './types/TObfuscationResultsObject';
-import { TOptionsPreset } from './types/options/TOptionsPreset';
-
-import { IInversifyContainerFacade } from './interfaces/container/IInversifyContainerFacade';
-import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
-import { IObfuscationResult } from './interfaces/source-code/IObfuscationResult';
-
-import { InversifyContainerFacade } from './container/InversifyContainerFacade';
-import { Options } from './options/Options';
-import { Utils } from './utils/Utils';
-
-class JavaScriptObfuscatorFacade {
-    /**
-     * @type {string | undefined}
-     */
-    public static version: string = process.env.VERSION ?? 'unknown';
-
-    /**
-     * @param {string} sourceCode
-     * @param {TInputOptions} inputOptions
-     * @returns {IObfuscationResult}
-     */
-    public static obfuscate (sourceCode: string, inputOptions: TInputOptions = {}): IObfuscationResult {
-        const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();
-
-        inversifyContainerFacade.load(sourceCode, '', inputOptions);
-
-        const javaScriptObfuscator: IJavaScriptObfuscator = inversifyContainerFacade
-            .get<IJavaScriptObfuscator>(ServiceIdentifiers.IJavaScriptObfuscator);
-        const obfuscationResult: IObfuscationResult = javaScriptObfuscator.obfuscate(sourceCode);
-
-        inversifyContainerFacade.unload();
-
-        return obfuscationResult;
-    }
-
-    /**
-     * @param {TSourceCodesObject} sourceCodesObject
-     * @param {TInputOptions} inputOptions
-     * @returns {TObfuscationResultsObject<TSourceCodesObject>}
-     */
-    public static obfuscateMultiple <TSourceCodesObject extends TDictionary<string>> (
-        sourceCodesObject: TSourceCodesObject,
-        inputOptions: TInputOptions = {}
-    ): TObfuscationResultsObject<TSourceCodesObject> {
-        if (typeof sourceCodesObject !== 'object') {
-            throw new Error('Source codes object should be a plain object');
-        }
-
-        return Object
-            .keys(sourceCodesObject)
-            .reduce(
-                (
-                    acc: TObfuscationResultsObject<TSourceCodesObject>,
-                    sourceCodeIdentifier: keyof TSourceCodesObject,
-                    index: number
-                ) => {
-                    const identifiersPrefix: string = Utils.getIdentifiersPrefixForMultipleSources(
-                        inputOptions.identifiersPrefix,
-                        index
-                    );
-
-                    const sourceCode: string = sourceCodesObject[sourceCodeIdentifier];
-                    const sourceCodeOptions: TInputOptions = {
-                        ...inputOptions,
-                        identifiersPrefix
-                    };
-
-                    return {
-                        ...acc,
-                        [sourceCodeIdentifier]: JavaScriptObfuscatorFacade.obfuscate(sourceCode, sourceCodeOptions)
-                    };
-                },
-                <TObfuscationResultsObject<TSourceCodesObject>>{}
-            );
-    }
-
-    /**
-     * @param {TOptionsPreset} optionsPreset
-     * @returns {TInputOptions}
-     */
-    public static getOptionsByPreset (optionsPreset: TOptionsPreset): TInputOptions {
-        return Options.getOptionsByPreset(optionsPreset);
-    }
-}
-
-export { JavaScriptObfuscatorFacade as JavaScriptObfuscator };