javascript-obfuscator 2.18.1 → 3.0.1

package/src/cli/utils/IdentifierNamesCacheFileUtils.ts

@@ -1,98 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-
-import { TIdentifierNamesCache } from '../../types/TIdentifierNamesCache';
-
-import { IFileData } from '../../interfaces/cli/IFileData';
-
-import { JavaScriptObfuscatorCLI } from '../JavaScriptObfuscatorCLI';
-
-/**
- * Utils to work with identifier names cache file
- */
-export class IdentifierNamesCacheFileUtils {
-    /**
-     * @type {string}
-     */
-    private static readonly identifierNamesCacheExtension: string = '.json';
-
-    /**
-     * @type {string}
-     */
-    private readonly identifierNamesCachePath: string | undefined;
-
-    /**
-     * @param {string} identifierNamesCachePath
-     */
-    public constructor (identifierNamesCachePath: string | undefined) {
-        this.identifierNamesCachePath = identifierNamesCachePath;
-    }
-
-    /**
-     * @param {string} filePath
-     * @returns {boolean}
-     */
-    private static isValidFilePath (filePath: string): boolean {
-        try {
-            return fs.statSync(filePath).isFile()
-                && path.extname(filePath) === IdentifierNamesCacheFileUtils.identifierNamesCacheExtension;
-        } catch {
-            return false;
-        }
-    }
-
-    /**
-     * @param {string} filePath
-     * @returns {IFileData}
-     */
-    private static readFile (filePath: string): IFileData {
-        return {
-            filePath: path.normalize(filePath),
-            content: fs.readFileSync(filePath, JavaScriptObfuscatorCLI.encoding)
-        };
-    }
-
-    /**
-     * @returns {TIdentifierNamesCache | null}
-     */
-    public readFile (): TIdentifierNamesCache | null {
-        if (!this.identifierNamesCachePath) {
-            return null;
-        }
-
-        if (!IdentifierNamesCacheFileUtils.isValidFilePath(this.identifierNamesCachePath)) {
-            throw new ReferenceError(`Given identifier names cache path must be a valid ${
-                IdentifierNamesCacheFileUtils.identifierNamesCacheExtension
-            } file path`);
-        }
-
-        const fileData: IFileData = IdentifierNamesCacheFileUtils.readFile(this.identifierNamesCachePath);
-
-        if (!fileData.content) {
-            // Initial state of identifier names cache file
-            return {};
-        }
-
-        try {
-            // Already written identifier names cache file
-            return JSON.parse(fileData.content);
-        } catch {
-            throw new ReferenceError('Identifier names cache file must contains a json dictionary with identifier names');
-        }
-    }
-
-    /**
-     * @param {TIdentifierNamesCache} identifierNamesCache
-     */
-    public writeFile (identifierNamesCache: TIdentifierNamesCache): void {
-        if (!this.identifierNamesCachePath) {
-            return;
-        }
-
-        const identifierNamesCacheJson: string = JSON.stringify(identifierNamesCache);
-
-        fs.writeFileSync(this.identifierNamesCachePath, identifierNamesCacheJson, {
-            encoding: JavaScriptObfuscatorCLI.encoding
-        });
-    }
-}

package/src/cli/utils/ObfuscatedCodeFileUtils.ts

@@ -1,143 +0,0 @@
-import * as fs from 'fs';
-import * as mkdirp from 'mkdirp';
-import * as path from 'path';
-
-import { TInputCLIOptions } from '../../types/options/TInputCLIOptions';
-
-import { StringSeparator } from '../../enums/StringSeparator';
-
-import { JavaScriptObfuscatorCLI } from '../JavaScriptObfuscatorCLI';
-
-export class ObfuscatedCodeFileUtils {
-    /**
-     * @type {string}
-     */
-    private readonly inputPath: string;
-
-    /**
-     * @type {TInputCLIOptions}
-     */
-    private readonly options: TInputCLIOptions;
-
-    /**
-     * @param {string} inputPath
-     * @param {TInputCLIOptions} options
-     */
-    public constructor (
-        inputPath: string,
-        options: TInputCLIOptions
-    ) {
-        this.inputPath = path.normalize(inputPath);
-        this.options = options;
-    }
-
-    /**
-     * @param {string} filePath
-     * @returns {string}
-     */
-    public getOutputCodePath (filePath: string): string {
-        const normalizedFilePath: string = path.normalize(filePath);
-        const normalizedRawOutputPath: string | null = this.options.output
-            ? path.normalize(this.options.output)
-            : null;
-
-        if (!normalizedRawOutputPath) {
-            return normalizedFilePath
-                .split(StringSeparator.Dot)
-                .map((value: string, index: number) => {
-                    return index === 0 ? `${value}${JavaScriptObfuscatorCLI.obfuscatedFilePrefix}` : value;
-                })
-                .join(StringSeparator.Dot);
-        }
-
-        const rawInputPathStats: fs.Stats = fs.lstatSync(this.inputPath);
-        const outputPathExtName: string = path.extname(normalizedRawOutputPath);
-
-        const isDirectoryRawInputPath: boolean = rawInputPathStats.isDirectory();
-        const isDirectoryRawOutputPath: boolean = !JavaScriptObfuscatorCLI
-            .availableInputExtensions
-            .includes(outputPathExtName);
-
-        if (isDirectoryRawInputPath) {
-            if (isDirectoryRawOutputPath) {
-                const parsedNormalizedFilePath: path.ParsedPath = path.parse(normalizedFilePath);
-                const baseOutputPath: string = path.join(
-                    parsedNormalizedFilePath.dir.replace(this.inputPath, ''),
-                    parsedNormalizedFilePath.base
-                );
-
-                return path.join(normalizedRawOutputPath, baseOutputPath);
-            } else {
-                throw new Error('Output path for directory obfuscation should be a directory path');
-            }
-        } else {
-            if (isDirectoryRawOutputPath) {
-                return path.join(normalizedRawOutputPath, path.basename(filePath));
-            } else {
-                return normalizedRawOutputPath;
-            }
-        }
-    }
-
-    /**
-     * @param {string} outputCodePath
-     * @param {string} sourceMapFileName
-     * @returns {string}
-     */
-    public getOutputSourceMapPath (outputCodePath: string, sourceMapFileName: string = ''): string {
-        if (!outputCodePath) {
-            throw new Error('Output code path is empty');
-        }
-
-        let normalizedOutputCodePath: string = path.normalize(outputCodePath);
-        let parsedOutputCodePath: path.ParsedPath = path.parse(normalizedOutputCodePath);
-
-        if (!parsedOutputCodePath.ext && !sourceMapFileName) {
-            throw new Error('Source map file name should be set when output code path is a directory path');
-        }
-
-        if (sourceMapFileName) {
-            const indexOfLastSeparator: number = normalizedOutputCodePath.lastIndexOf(path.sep);
-            let sourceMapPath: string;
-
-            if (parsedOutputCodePath.ext) {
-                // File path with directory, like: `foo/bar.js`, or without, like: `bar.js`
-                const isFilePathWithDirectory: boolean = indexOfLastSeparator > 0;
-
-                sourceMapPath = isFilePathWithDirectory
-                    ? normalizedOutputCodePath.slice(0, indexOfLastSeparator)
-                    : '';
-            } else {
-                sourceMapPath = normalizedOutputCodePath;
-            }
-
-            // remove possible drive letter for win32 environment
-            const normalizedSourceMapFilePath: string = sourceMapFileName.replace(/^[a-zA-Z]:\\*/, '');
-
-            normalizedOutputCodePath = path.join(sourceMapPath, normalizedSourceMapFilePath);
-        }
-
-        if (!/\.js\.map$/.test(normalizedOutputCodePath)) {
-            parsedOutputCodePath = path.parse(normalizedOutputCodePath);
-            const outputCodePathWithoutExtension: string = path.join(parsedOutputCodePath.dir, parsedOutputCodePath.name);
-
-            normalizedOutputCodePath = `${outputCodePathWithoutExtension}.js.map`;
-        } else if (/\.js$/.test(normalizedOutputCodePath)) {
-            normalizedOutputCodePath += '.map';
-        }
-
-        return normalizedOutputCodePath;
-    }
-
-    /**
-     * @param {string} outputPath
-     * @param {string} data
-     */
-    public writeFile (outputPath: string, data: string): void {
-        mkdirp.sync(path.dirname(outputPath));
-
-        fs.writeFileSync(outputPath, data, {
-            encoding: JavaScriptObfuscatorCLI.encoding
-        });
-    }
-}

package/src/cli/utils/SourceCodeFileUtils.ts

@@ -1,167 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import multimatch from 'multimatch';
-
-import { TInputCLIOptions } from '../../types/options/TInputCLIOptions';
-
-import { IFileData } from '../../interfaces/cli/IFileData';
-
-import { JavaScriptObfuscatorCLI } from '../JavaScriptObfuscatorCLI';
-
-export class SourceCodeFileUtils {
-    /**
-     * @type {string}
-     */
-    private readonly inputPath: string;
-
-    /**
-     * @type {TInputCLIOptions}
-     */
-    private readonly options: TInputCLIOptions;
-
-    /**
-     * @param {string} inputPath
-     * @param {TInputCLIOptions} options
-     */
-    public constructor (
-        inputPath: string,
-        options: TInputCLIOptions
-    ) {
-        this.inputPath = inputPath;
-        this.options = options;
-    }
-
-    /**
-     * @param {string} filePath
-     * @param {string[]} excludePatterns
-     * @returns {boolean}
-     */
-    private static isExcludedPath (filePath: string, excludePatterns: string[] = []): boolean {
-        if (!excludePatterns.length) {
-            return false;
-        }
-
-        const fileName: string = path.basename(filePath);
-        const isExcludedFilePathByGlobPattern: boolean = !!multimatch([filePath], excludePatterns).length;
-        const isExcludedFilePathByInclusion: boolean = excludePatterns.some((excludePattern: string) =>
-            filePath.includes(excludePattern) || fileName.includes(excludePattern)
-        );
-
-        return isExcludedFilePathByInclusion || isExcludedFilePathByGlobPattern;
-    }
-
-    /**
-     * @param {string} filePath
-     * @returns {boolean}
-     */
-    private static isDirectoryPath (filePath: string): boolean {
-        try {
-            return fs.statSync(filePath).isDirectory();
-        } catch {
-            return false;
-        }
-    }
-
-    /**
-     * @param {string} filePath
-     * @returns {boolean}
-     */
-    private static isFilePath (filePath: string): boolean {
-        try {
-            return fs.statSync(filePath).isFile();
-        } catch {
-            return false;
-        }
-    }
-
-    /**
-     * @param {string} directoryPath
-     * @param {string[]} excludePatterns
-     * @returns {boolean}
-     */
-    private static isValidDirectory (directoryPath: string, excludePatterns: string[] = []): boolean {
-        return !SourceCodeFileUtils.isExcludedPath(directoryPath, excludePatterns);
-    }
-
-    /**
-     * @param {string} filePath
-     * @param {string[]} excludePatterns
-     * @returns {boolean}
-     */
-    private static isValidFile (filePath: string, excludePatterns: string[] = []): boolean {
-        return JavaScriptObfuscatorCLI.availableInputExtensions.includes(path.extname(filePath))
-            && !filePath.includes(JavaScriptObfuscatorCLI.obfuscatedFilePrefix)
-            && !SourceCodeFileUtils.isExcludedPath(filePath, excludePatterns);
-    }
-
-    /**
-     * @param {string} filePath
-     * @returns {string}
-     */
-    private static readFile (filePath: string): IFileData {
-        return {
-            filePath: path.normalize(filePath),
-            content: fs.readFileSync(filePath, JavaScriptObfuscatorCLI.encoding)
-        };
-    }
-
-    /**
-     * @returns {IFileData[]}
-     */
-    public readSourceCode (): IFileData[] {
-        if (
-            SourceCodeFileUtils.isFilePath(this.inputPath)
-            && SourceCodeFileUtils.isValidFile(this.inputPath, this.options.exclude)
-        ) {
-            return [SourceCodeFileUtils.readFile(this.inputPath)];
-        }
-
-        if (
-            SourceCodeFileUtils.isDirectoryPath(this.inputPath)
-            && SourceCodeFileUtils.isValidDirectory(this.inputPath, this.options.exclude)
-        ) {
-            return this.readDirectoryRecursive(this.inputPath);
-        }
-
-        const availableFilePaths: string = JavaScriptObfuscatorCLI
-            .availableInputExtensions
-            .map((extension: string) => `\`${extension}\``)
-            .join(', ');
-
-        throw new ReferenceError(`Given input path must be a valid ${availableFilePaths} file or directory path`);
-    }
-
-    /**
-     * @param {string} directoryPath
-     * @param {IFileData[]} filesData
-     * @returns {IFileData[]}
-     */
-    private readDirectoryRecursive (directoryPath: string, filesData: IFileData[] = []): IFileData[] {
-        fs.readdirSync(directoryPath, JavaScriptObfuscatorCLI.encoding)
-            .forEach((fileName: string) => {
-                const filePath: string = path.join(directoryPath, fileName);
-
-                if (
-                    SourceCodeFileUtils.isDirectoryPath(filePath)
-                    && SourceCodeFileUtils.isValidDirectory(filePath, this.options.exclude)
-                ) {
-                    filesData.push(...this.readDirectoryRecursive(filePath));
-
-                    return;
-                }
-
-                if (
-                    SourceCodeFileUtils.isFilePath(filePath)
-                    && SourceCodeFileUtils.isValidFile(filePath, this.options.exclude)
-                ) {
-                    const fileData: IFileData = SourceCodeFileUtils.readFile(filePath);
-
-                    filesData.push(fileData);
-
-                    return;
-                }
-            });
-
-        return filesData;
-    }
-}

package/src/code-transformers/AbstractCodeTransformer.ts

@@ -1,46 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
-import { IOptions } from '../interfaces/options/IOptions';
-import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
-
-import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
-import { CodeTransformationStage } from '../enums/code-transformers/CodeTransformationStage';
-
-@injectable()
-export abstract class AbstractCodeTransformer implements ICodeTransformer {
-    /**
-     * @type {CodeTransformer[]}
-     */
-    public readonly runAfter: CodeTransformer[] | undefined;
-
-    /**
-     * @type {IOptions}
-     */
-    protected readonly options: IOptions;
-
-    /**
-     * @type {IRandomGenerator}
-     */
-    protected readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    protected constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.randomGenerator = randomGenerator;
-        this.options = options;
-    }
-
-    /**
-     * @param {string} code
-     * @param {CodeTransformationStage} codeTransformationStage
-     * @returns {string}
-     */
-    public abstract transformCode (code: string, codeTransformationStage: CodeTransformationStage): string;
-}

package/src/code-transformers/CodeTransformersRunner.ts

@@ -1,100 +0,0 @@
-import { inject, injectable } from 'inversify';
-
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import { TCodeTransformerFactory } from '../types/container/code-transformers/TCodeTransformerFactory';
-import { TDictionary } from '../types/TDictionary';
-
-import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
-import { ICodeTransformersRunner } from '../interfaces/code-transformers/ICodeTransformersRunner';
-import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
-
-import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
-import { CodeTransformationStage } from '../enums/code-transformers/CodeTransformationStage';
-
-@injectable()
-export class CodeTransformersRunner implements ICodeTransformersRunner {
-    /**
-     * @type {TCodeTransformerFactory}
-     */
-    private readonly codeTransformerFactory: TCodeTransformerFactory;
-
-    /**
-     * @type {ITransformerNamesGroupsBuilder}
-     */
-    private readonly codeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
-        CodeTransformer,
-        ICodeTransformer
-    >;
-
-    /**
-     * @param {TNodeTransformerFactory} codeTransformerFactory
-     * @param {ITransformerNamesGroupsBuilder} codeTransformerNamesGroupsBuilder
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__ICodeTransformer)
-            codeTransformerFactory: TCodeTransformerFactory,
-        @inject(ServiceIdentifiers.ICodeTransformerNamesGroupsBuilder)
-            codeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<
-                CodeTransformer,
-                ICodeTransformer
-            >,
-    ) {
-        this.codeTransformerFactory = codeTransformerFactory;
-        this.codeTransformerNamesGroupsBuilder = codeTransformerNamesGroupsBuilder;
-    }
-
-    /**
-     * @param {string} code
-     * @param {CodeTransformer[]} codeTransformerNames
-     * @param {CodeTransformationStage} codeTransformationStage
-     * @returns {string}
-     */
-    public transform (
-        code: string,
-        codeTransformerNames: CodeTransformer[],
-        codeTransformationStage: CodeTransformationStage
-    ): string {
-        if (!codeTransformerNames.length) {
-            return code;
-        }
-
-        const normalizedCodeTransformers: TDictionary<ICodeTransformer> =
-            this.buildNormalizedCodeTransformers(codeTransformerNames, codeTransformationStage);
-        const codeTransformerNamesGroups: CodeTransformer[][] =
-            this.codeTransformerNamesGroupsBuilder.build(normalizedCodeTransformers);
-
-        for (const nodeTransformerNamesGroup of codeTransformerNamesGroups) {
-            for (const nodeTransformerName of nodeTransformerNamesGroup) {
-                const codeTransformer: ICodeTransformer = normalizedCodeTransformers[nodeTransformerName];
-
-                code = codeTransformer.transformCode(code, codeTransformationStage);
-            }
-        }
-
-        return code;
-    }
-
-    /**
-     * @param {NodeTransformer[]} codeTransformerNames
-     * @param {NodeTransformationStage} codeTransformationStage
-     * @returns {TDictionary<INodeTransformer>}
-     */
-    private buildNormalizedCodeTransformers (
-        codeTransformerNames: CodeTransformer[],
-        codeTransformationStage: CodeTransformationStage
-    ): TDictionary<ICodeTransformer> {
-        return codeTransformerNames
-            .reduce<TDictionary<ICodeTransformer>>(
-                (acc: TDictionary<ICodeTransformer>, codeTransformerName: CodeTransformer) => {
-                    const codeTransformer: ICodeTransformer = this.codeTransformerFactory(codeTransformerName);
-
-                    return {
-                        ...acc,
-                        [codeTransformerName]: codeTransformer
-                    };
-                },
-                {}
-            );
-    }
-}

package/src/code-transformers/preparing-transformers/HashbangOperatorTransformer.ts

@@ -1,72 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-
-import { CodeTransformationStage } from '../../enums/code-transformers/CodeTransformationStage';
-
-import { AbstractCodeTransformer } from '../AbstractCodeTransformer';
-
-@injectable()
-export class HashbangOperatorTransformer extends AbstractCodeTransformer {
-    /**
-     * @type {string | null}
-     */
-    private hashbangOperatorLine: string | null = null;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * Removes hashbang operator before AST transformation and appends it back after
-     *
-     * @param {string} code
-     * @param {CodeTransformationStage} codeTransformationStage
-     * @returns {string}
-     */
-    public transformCode (code: string, codeTransformationStage: CodeTransformationStage): string {
-        switch (codeTransformationStage) {
-            case CodeTransformationStage.PreparingTransformers:
-                return this.removeAndSaveHashbangOperatorLine(code);
-
-            case CodeTransformationStage.FinalizingTransformers:
-                return this.appendSavedHashbangOperatorLine(code);
-
-            default:
-                return code;
-        }
-    }
-
-    /**
-     * @param {string} code
-     * @returns {string}
-     */
-    private removeAndSaveHashbangOperatorLine (code: string): string {
-        return code
-            .replace(/^#!.*$(\r?\n)*/m, (substring: string) => {
-                if (substring) {
-                    this.hashbangOperatorLine = substring;
-                }
-
-                return '';
-            })
-            .trim();
-    }
-
-    /**
-     * @param {string} code
-     * @returns {string}
-     */
-    private appendSavedHashbangOperatorLine (code: string): string {
-        return `${this.hashbangOperatorLine ?? ''}${code}`;
-    }
-}

package/src/constants/AlphabetString.ts

@@ -1 +0,0 @@
-export const alphabetString: string = 'abcdefghijklmnopqrstuvwxyz';

package/src/constants/AlphabetStringUppercase.ts

@@ -1,3 +0,0 @@
-import { alphabetString } from './AlphabetString';
-
-export const alphabetStringUppercase: string = alphabetString.toUpperCase();

package/src/constants/Base64Alphabet.ts

@@ -1,5 +0,0 @@
-import { alphabetStringUppercase } from './AlphabetStringUppercase';
-import { alphabetString } from './AlphabetString';
-import { numbersString } from './NumbersString';
-
-export const base64alphabet: string = `${alphabetStringUppercase}${alphabetString}${numbersString}+/=`;

package/src/constants/Base64AlphabetSwapped.ts

@@ -1,8 +0,0 @@
-import { alphabetStringUppercase } from './AlphabetStringUppercase';
-import { alphabetString } from './AlphabetString';
-import { numbersString } from './NumbersString';
-
-/**
- * Swapped lowercase and uppercase groups of alphabet to prevent easy decode
- */
-export const base64alphabetSwapped: string = `${alphabetString}${alphabetStringUppercase}${numbersString}+/=`;

package/src/constants/EcmaVersion.ts

@@ -1,3 +0,0 @@
-import * as acorn from 'acorn';
-
-export const ecmaVersion = <acorn.Options['ecmaVersion'] & number>13;

package/src/constants/NumbersString.ts

@@ -1 +0,0 @@
-export const numbersString: string = '0123456789';