javascript-obfuscator 2.18.0 → 3.0.0

package/src/generators/identifier-names-generators/AbstractIdentifierNamesGenerator.ts

@@ -1,142 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-
-import { IIdentifierNamesGenerator } from '../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-
-import { NodeGuards } from '../../node/NodeGuards';
-
-@injectable()
-export abstract class AbstractIdentifierNamesGenerator implements IIdentifierNamesGenerator {
-    /**
-     * @type {IOptions}
-     */
-    protected readonly options: IOptions;
-
-    /**
-     * @type {IRandomGenerator}
-     */
-    protected readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @type {Set<string>}
-     */
-    protected readonly preservedNamesSet: Set<string> = new Set();
-
-    /**
-     * @type {Map<TNodeWithLexicalScope, Set<string>>}
-     */
-    protected readonly lexicalScopesPreservedNamesMap: Map<TNodeWithLexicalScope, Set<string>> = new Map();
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        this.randomGenerator = randomGenerator;
-        this.options = options;
-    }
-
-    /**
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public generate (lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string {
-        return NodeGuards.isProgramNode(lexicalScopeNode)
-            ? this.generateForGlobalScope()
-            : this.generateForLexicalScope(lexicalScopeNode);
-    }
-
-    /**
-     * @param {string} name
-     */
-    public preserveName (name: string): void {
-        this.preservedNamesSet.add(name);
-    }
-
-    /**
-     * @param {string} name
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     */
-    public preserveNameForLexicalScope (name: string, lexicalScopeNode: TNodeWithLexicalScope): void {
-        const preservedNamesForLexicalScopeSet: Set<string> =
-            this.lexicalScopesPreservedNamesMap.get(lexicalScopeNode) ?? new Set();
-
-        preservedNamesForLexicalScopeSet.add(name);
-
-        this.lexicalScopesPreservedNamesMap.set(lexicalScopeNode, preservedNamesForLexicalScopeSet);
-    }
-
-    /**
-     * @param {string} name
-     * @returns {boolean}
-     */
-    public isValidIdentifierName (name: string): boolean {
-        return this.notReservedName(name) && !this.preservedNamesSet.has(name);
-    }
-
-    /**
-     * @param {string} name
-     * @param {TNodeWithLexicalScope[]} lexicalScopeNodes
-     * @returns {boolean}
-     */
-    public isValidIdentifierNameInLexicalScopes (name: string, lexicalScopeNodes: TNodeWithLexicalScope[]): boolean {
-        if (!this.isValidIdentifierName(name)) {
-            return false;
-        }
-
-        for (const lexicalScope of lexicalScopeNodes) {
-            const preservedNamesForLexicalScopeSet: Set<string> | null =
-                this.lexicalScopesPreservedNamesMap.get(lexicalScope) ?? null;
-
-            if (!preservedNamesForLexicalScopeSet) {
-                continue;
-            }
-
-            if (preservedNamesForLexicalScopeSet.has(name)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * @param {string} name
-     * @returns {boolean}
-     */
-    private notReservedName (name: string): boolean {
-        return this.options.reservedNames.length
-            ? !this.options.reservedNames.some((reservedName: string) =>
-                new RegExp(reservedName, 'g').exec(name) !== null
-            )
-            : true;
-
-    }
-
-    /**
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public abstract generateForGlobalScope (nameLength?: number): string;
-
-    /**
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public abstract generateForLexicalScope (lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
-
-    /**
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public abstract generateNext (nameLength?: number): string;
-}

package/src/generators/identifier-names-generators/DictionaryIdentifierNamesGenerator.ts

@@ -1,175 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-
-import { AbstractIdentifierNamesGenerator } from './AbstractIdentifierNamesGenerator';
-import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-import { NodeLexicalScopeUtils } from '../../node/NodeLexicalScopeUtils';
-
-@injectable()
-export class DictionaryIdentifierNamesGenerator extends AbstractIdentifierNamesGenerator {
-    /**
-     * @type {IArrayUtils}
-     */
-    private readonly arrayUtils: IArrayUtils;
-
-    /**
-     * @type {Set<string>}
-     */
-    private identifierNamesSet: Set<string>;
-    
-    /**
-     * @type {IterableIterator<string>}
-     */
-    private identifiersIterator: IterableIterator<string>;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     * @param {IArrayUtils} arrayUtils
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions,
-        @inject(ServiceIdentifiers.IArrayUtils) arrayUtils: IArrayUtils,
-    ) {
-        super(randomGenerator, options);
-
-        this.arrayUtils = arrayUtils;
-        this.identifierNamesSet = new Set(this.getInitialIdentifierNames(this.options.identifiersDictionary));
-        this.identifiersIterator = this.identifierNamesSet.values();
-    }
-
-    /**
-     * @param {string} identifierName
-     * @returns {string | null}
-     */
-    private static incrementIdentifierName (identifierName: string): string | null {
-        let newIdentifierName: string = '';
-        let isSuccess: boolean = false;
-
-        for (const character of identifierName) {
-            if (!isSuccess && character === character.toUpperCase()) {
-                newIdentifierName += character.toLowerCase();
-            } else if (!isSuccess && character === character.toLowerCase()) {
-                newIdentifierName += character.toUpperCase();
-                isSuccess = true;
-            } else {
-                newIdentifierName += character;
-            }
-        }
-
-        if (isSuccess) {
-            return newIdentifierName;
-        }
-
-        return null;
-    }
-
-    public generateNext (): string {
-        const identifierName: string = this.generateNewDictionaryName();
-
-        this.preserveName(identifierName);
-
-        return identifierName;
-    }
-
-    /**
-     * @returns {string}
-     */
-    public generateForGlobalScope (): string {
-        const prefix: string = this.options.identifiersPrefix ?
-            `${this.options.identifiersPrefix}`
-            : '';
-        const identifierName: string = this.generateNewDictionaryName();
-        const identifierNameWithPrefix: string = `${prefix}${identifierName}`;
-
-        if (!this.isValidIdentifierName(identifierNameWithPrefix)) {
-            return this.generateForGlobalScope();
-        }
-
-        this.preserveName(identifierNameWithPrefix);
-
-        return identifierNameWithPrefix;
-    }
-
-    /**
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @returns {string}
-     */
-    public generateForLexicalScope (lexicalScopeNode: TNodeWithLexicalScope): string {
-        const lexicalScopes: TNodeWithLexicalScope[] = [
-            lexicalScopeNode,
-            ...NodeLexicalScopeUtils.getLexicalScopes(lexicalScopeNode)
-        ];
-        const identifierName: string = this.generateNewDictionaryName();
-
-        if (!this.isValidIdentifierNameInLexicalScopes(identifierName, lexicalScopes)) {
-            return this.generateForLexicalScope(lexicalScopeNode);
-        }
-
-        this.preserveNameForLexicalScope(identifierName, lexicalScopeNode);
-
-        return identifierName;
-    }
-
-    /**
-     * @returns {string}
-     */
-    private generateNewDictionaryName (): string {
-        if (!this.identifierNamesSet.size) {
-            throw new Error('Too many identifiers in the code, add more words to identifiers dictionary');
-        }
-
-        const iteratorResult: IteratorResult<string> = this.identifiersIterator.next();
-
-        if (!iteratorResult.done) {
-            const identifierName: string =iteratorResult.value;
-
-            if (!this.isValidIdentifierName(identifierName)) {
-                return this.generateNewDictionaryName();
-            }
-
-            return iteratorResult.value;
-        }
-
-        this.identifierNamesSet = new Set(this.getIncrementedIdentifierNames([...this.identifierNamesSet]));
-        this.identifiersIterator = this.identifierNamesSet.values();
-
-        return this.generateNewDictionaryName();
-    }
-
-    /**
-     * @param {string[]} identifierNames
-     * @returns {string[]}
-     */
-    private getInitialIdentifierNames (identifierNames: string[]): string[] {
-        const formattedIdentifierNames: string[] = identifierNames
-            .filter(Boolean)
-            .map((identifierName: string) => identifierName.toLowerCase());
-
-        return this.arrayUtils.shuffle(formattedIdentifierNames);
-    }
-
-    /**
-     * @param {string[]} identifierNames
-     * @returns {string[]}
-     */
-    private getIncrementedIdentifierNames (identifierNames: string[]): string[] {
-        const formattedIdentifierNames: string[] = [];
-
-        for (const identifierName of identifierNames) {
-            const newIdentifierName: string | null = DictionaryIdentifierNamesGenerator
-                .incrementIdentifierName(identifierName);
-
-            if (newIdentifierName) {
-                formattedIdentifierNames.push(newIdentifierName);
-            }
-        }
-
-        return this.arrayUtils.shuffle(formattedIdentifierNames);
-    }
-}

package/src/generators/identifier-names-generators/HexadecimalIdentifierNamesGenerator.ts

@@ -1,73 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-
-import { AbstractIdentifierNamesGenerator } from './AbstractIdentifierNamesGenerator';
-import { NumberUtils } from '../../utils/NumberUtils';
-import { Utils } from '../../utils/Utils';
-
-@injectable()
-export class HexadecimalIdentifierNamesGenerator extends AbstractIdentifierNamesGenerator {
-    /**
-     * @type {number}
-     */
-    private static readonly baseIdentifierNameLength: number = 6;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public generateNext (nameLength?: number): string {
-        const rangeMinInteger: number = 10000;
-        const rangeMaxInteger: number = 99_999_999;
-        const randomInteger: number = this.randomGenerator.getRandomInteger(rangeMinInteger, rangeMaxInteger);
-        const hexadecimalNumber: string = NumberUtils.toHex(randomInteger);
-        const prefixLength: number = Utils.hexadecimalPrefix.length;
-        const baseNameLength: number = (nameLength ?? HexadecimalIdentifierNamesGenerator.baseIdentifierNameLength)
-            + prefixLength;
-        const baseIdentifierName: string = hexadecimalNumber.slice(0, baseNameLength);
-        const identifierName: string = `_${baseIdentifierName}`;
-
-        if (!this.isValidIdentifierName(identifierName)) {
-            return this.generateNext(nameLength);
-        }
-
-        this.preserveName(identifierName);
-
-        return identifierName;
-    }
-
-    /**
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public generateForGlobalScope (nameLength?: number): string {
-        const identifierName: string = this.generateNext(nameLength);
-
-        return `${this.options.identifiersPrefix}${identifierName}`.replace('__', '_');
-    }
-
-    /**
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public generateForLexicalScope (lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string {
-        return this.generateNext(nameLength);
-    }
-}

package/src/generators/identifier-names-generators/MangledIdentifierNamesGenerator.ts

@@ -1,256 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-
-import { numbersString } from '../../constants/NumbersString';
-import { alphabetString } from '../../constants/AlphabetString';
-import { alphabetStringUppercase } from '../../constants/AlphabetStringUppercase';
-
-import { AbstractIdentifierNamesGenerator } from './AbstractIdentifierNamesGenerator';
-import { NodeLexicalScopeUtils } from '../../node/NodeLexicalScopeUtils';
-
-@injectable()
-export class MangledIdentifierNamesGenerator extends AbstractIdentifierNamesGenerator {
-    /**
-     * @type {string}
-     */
-    private static readonly initMangledNameCharacter: string = '9';
-
-    /**
-     * @type {WeakMap<TNodeWithLexicalScope, string>}
-     */
-    private static readonly lastMangledNameInScopeMap: WeakMap <TNodeWithLexicalScope, string> = new WeakMap();
-
-    /**
-     * @type {string[]}
-     */
-    private static readonly nameSequence: string[] = [
-        ...`${numbersString}${alphabetString}${alphabetStringUppercase}`
-    ];
-
-    /**
-     * Reserved JS words with length of 2-4 symbols that can be possible generated with this replacer
-     *
-     * @type {Set<string>}
-     */
-    private static readonly reservedNamesSet: Set<string> = new Set([
-        'byte', 'case', 'char', 'do', 'else', 'enum', 'eval', 'for', 'goto',
-        'if', 'in', 'int', 'let', 'long', 'new', 'null', 'this', 'true', 'try',
-        'var', 'void', 'with'
-    ]);
-
-    /**
-     * @type {string}
-     */
-    private previousMangledName: string = MangledIdentifierNamesGenerator.initMangledNameCharacter;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * Generates next name based on a global previous mangled name
-     * We can ignore nameLength parameter here, it hasn't sense with this generator
-     *
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public generateNext (nameLength?: number): string {
-        const identifierName: string = this.generateNewMangledName(this.previousMangledName);
-
-        this.updatePreviousMangledName(identifierName);
-        this.preserveName(identifierName);
-
-        return identifierName;
-    }
-
-    /**
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public generateForGlobalScope (nameLength?: number): string {
-        const prefix: string = this.options.identifiersPrefix ?
-            `${this.options.identifiersPrefix}`
-            : '';
-        const identifierName: string = this.generateNewMangledName(this.previousMangledName);
-        const identifierNameWithPrefix: string = `${prefix}${identifierName}`;
-
-        this.updatePreviousMangledName(identifierName);
-
-        if (!this.isValidIdentifierName(identifierNameWithPrefix)) {
-            return this.generateForGlobalScope(nameLength);
-        }
-
-        this.preserveName(identifierNameWithPrefix);
-
-        return identifierNameWithPrefix;
-    }
-
-    /**
-     * @param {TNodeWithLexicalScope} lexicalScopeNode
-     * @param {number} nameLength
-     * @returns {string}
-     */
-    public generateForLexicalScope (lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string {
-        const lexicalScopes: TNodeWithLexicalScope[] = [
-            lexicalScopeNode,
-            ...NodeLexicalScopeUtils.getLexicalScopes(lexicalScopeNode)
-        ];
-
-        const lastMangledNameForScope: string = this.getLastMangledNameForScopes(lexicalScopes);
-
-        let identifierName: string = lastMangledNameForScope;
-
-        do {
-            identifierName = this.generateNewMangledName(identifierName);
-        } while (!this.isValidIdentifierNameInLexicalScopes(identifierName, lexicalScopes));
-
-        MangledIdentifierNamesGenerator.lastMangledNameInScopeMap.set(lexicalScopeNode, identifierName);
-
-        this.updatePreviousMangledName(identifierName);
-        this.preserveNameForLexicalScope(identifierName, lexicalScopeNode);
-
-        return identifierName;
-    }
-
-    /**
-     * @param {string} nextName
-     * @param {string} prevName
-     * @returns {boolean}
-     */
-    // eslint-disable-next-line complexity
-    public isIncrementedMangledName (nextName: string, prevName: string): boolean {
-        if (nextName === prevName) {
-            return false;
-        }
-
-        const nextNameLength: number = nextName.length;
-        const prevNameLength: number = prevName.length;
-
-        if (nextNameLength !== prevNameLength) {
-            return nextNameLength > prevNameLength;
-        }
-
-        const nameSequence: string[] = this.getNameSequence();
-
-        for (let i: number = 0; i < nextNameLength; i++) {
-            const nextNameCharacter: string = nextName[i];
-            const prevNameCharacter: string = prevName[i];
-
-            if (nextNameCharacter === prevNameCharacter) {
-                continue;
-            }
-
-            const indexOfNextNameCharacter: number = nameSequence.indexOf(nextNameCharacter);
-            const indexOfPrevNameCharacter: number = nameSequence.indexOf(prevNameCharacter);
-
-            return indexOfNextNameCharacter > indexOfPrevNameCharacter;
-        }
-
-        throw new Error('Something goes wrong during comparison of mangled names');
-    }
-
-    /**
-     * @param {string} mangledName
-     * @returns {boolean}
-     */
-    public override isValidIdentifierName (mangledName: string): boolean {
-        return super.isValidIdentifierName(mangledName)
-            && !MangledIdentifierNamesGenerator.reservedNamesSet.has(mangledName);
-    }
-
-    /**
-     * @returns {string[]}
-     */
-    protected getNameSequence (): string[] {
-        return MangledIdentifierNamesGenerator.nameSequence;
-    }
-
-    /**
-     * @param {string} name
-     */
-    protected updatePreviousMangledName (name: string): void {
-        if (!this.isIncrementedMangledName(name, this.previousMangledName)) {
-            return;
-        }
-
-        this.previousMangledName = name;
-    }
-
-    /**
-     * @param {string} previousMangledName
-     * @returns {string}
-     */
-    protected generateNewMangledName (previousMangledName: string): string {
-        const generateNewMangledName: (name: string) => string = (name: string): string => {
-            const nameSequence: string[] = this.getNameSequence();
-            const nameSequenceLength: number = nameSequence.length;
-            const nameLength: number = name.length;
-
-            const zeroSequence: (num: number) => string = (num: number): string => {
-                return '0'.repeat(num);
-            };
-
-            let index: number = nameLength - 1;
-
-            do {
-                const character: string = name[index];
-                const indexInSequence: number = nameSequence.indexOf(character);
-                const lastNameSequenceIndex: number = nameSequenceLength - 1;
-
-                if (indexInSequence !== lastNameSequenceIndex) {
-                    const previousNamePart: string = name.slice(0, index);
-                    const nextCharacter: string = nameSequence[indexInSequence + 1];
-                    const zeroSequenceLength: number = nameLength - (index + 1);
-                    const zeroSequenceCharacters: string = zeroSequence(zeroSequenceLength);
-
-                    return previousNamePart + nextCharacter + zeroSequenceCharacters;
-                }
-
-                --index;
-            } while (index >= 0);
-
-            const firstLetterCharacter: string = nameSequence[numbersString.length];
-
-            return `${firstLetterCharacter}${zeroSequence(nameLength)}`;
-        };
-
-        let newMangledName: string = generateNewMangledName(previousMangledName);
-
-        if (!this.isValidIdentifierName(newMangledName)) {
-            newMangledName = this.generateNewMangledName(newMangledName);
-        }
-
-        return newMangledName;
-    }
-
-    /**
-     * @param {TNodeWithLexicalScope[]} lexicalScopeNodes
-     * @returns {string}
-     */
-    private getLastMangledNameForScopes (lexicalScopeNodes: TNodeWithLexicalScope[]): string {
-        for (const lexicalScope of lexicalScopeNodes) {
-            const lastMangledName: string | null = MangledIdentifierNamesGenerator.lastMangledNameInScopeMap
-                .get(lexicalScope) ?? null;
-
-            if (!lastMangledName) {
-                continue;
-            }
-
-            return lastMangledName;
-        }
-
-        return MangledIdentifierNamesGenerator.initMangledNameCharacter;
-    }
-}