javascript-obfuscator 2.18.0 → 3.0.0

package/src/utils/AbstractTransformerNamesGroupsBuilder.ts

@@ -1,104 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import { TDictionary } from '../types/TDictionary';
-import { TTransformersRelationEdge } from '../types/utils/TTransformersRelationEdge';
-
-import { ILevelledTopologicalSorter } from '../interfaces/utils/ILevelledTopologicalSorter';
-import { ITransformer } from '../interfaces/ITransformer';
-import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
-
-@injectable()
-export abstract class AbstractTransformerNamesGroupsBuilder <
-    TTransformerName extends string,
-    TTransformer extends ITransformer<TTransformerName>
-> implements ITransformerNamesGroupsBuilder <
-    TTransformerName,
-    TTransformer
-> {
-    /**
-     * @type {ILevelledTopologicalSorter<TTransformerName>}
-     */
-    private readonly levelledTopologicalSorter: ILevelledTopologicalSorter<TTransformerName>;
-
-    public constructor (
-        @inject(ServiceIdentifiers.ILevelledTopologicalSorter)
-            levelledTopologicalSorter: ILevelledTopologicalSorter<TTransformerName>
-    ) {
-        this.levelledTopologicalSorter = levelledTopologicalSorter;
-    }
-
-    /**
-     * Builds sorted transformer names by topological sort with levels
-     *
-     * For example, if SplitString transformer has following dependencies inside `runAfter` property:
-     *  - NodeTransformer.ObjectExpressionKeysTransformer,
-     *  - NodeTransformer.TemplateLiteralTransformer
-     *
-     *  Than result node transformer names groups will be like:
-     *  [
-     *      [
-     *          SomeTransformerA,
-     *          ObjectExpressionKeysTransformer,
-     *          TemplateLiteralTransformer,
-     *          SomeTransformerB
-     *      ],
-     *      [
-     *          SplitStringTransformer
-     *      ]
-     *  ]
-     *
-     * @param {TDictionary<TTransformer>} normalizedTransformers
-     * @returns {TTransformerName[][]}
-     */
-    public build (normalizedTransformers: TDictionary<TTransformer>): TTransformerName[][] {
-        const transformerNames: TTransformerName[] = <TTransformerName[]>Object.keys(normalizedTransformers);
-        const relationEdges: TTransformersRelationEdge<TTransformerName>[] = this.buildTransformersRelationEdges(
-            transformerNames,
-            normalizedTransformers
-        );
-
-        for (const [precedent, consequent] of relationEdges) {
-            this.levelledTopologicalSorter.add(precedent, consequent);
-        }
-
-        return this.levelledTopologicalSorter.sortByGroups();
-    }
-
-    /**
-     * @param {TTransformerName[]} transformerNames
-     * @param {TDictionary<TTransformer>} normalizedTransformers
-     * @returns {TTransformersRelationEdge<TTransformerName>[]}
-     */
-    private buildTransformersRelationEdges (
-        transformerNames: TTransformerName[],
-        normalizedTransformers: TDictionary<TTransformer>
-    ): TTransformersRelationEdge<TTransformerName>[] {
-        const relationEdges: TTransformersRelationEdge<TTransformerName>[] = [];
-
-        for (const transformerName of transformerNames) {
-            const transformer: TTransformer = normalizedTransformers[transformerName];
-
-            const runAfterRelations: TTransformerName[] | undefined = transformer.runAfter;
-            const areRunAfterRelationsEmpty = !runAfterRelations || !runAfterRelations.length;
-
-            if (areRunAfterRelationsEmpty) {
-                relationEdges.push([transformerName, null]);
-                continue;
-            }
-
-            for (const runAfterRelation of runAfterRelations) {
-                const isUnknownRelation: boolean = normalizedTransformers[runAfterRelation] === undefined;
-
-                if (isUnknownRelation) {
-                    relationEdges.push([transformerName, null]);
-                    continue;
-                }
-
-                relationEdges.push([runAfterRelation, transformerName]);
-            }
-        }
-
-        return relationEdges;
-    }
-}

package/src/utils/ArrayUtils.ts

@@ -1,137 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import { IArrayUtils } from '../interfaces/utils/IArrayUtils';
-import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
-
-@injectable()
-export class ArrayUtils implements IArrayUtils {
-    /**
-     * @type {IRandomGenerator}
-     */
-    private readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator
-    ) {
-        this.randomGenerator = randomGenerator;
-    }
-
-    /**
-     * @param {number} length
-     * @returns {number[]}
-     */
-    public createWithRange (length: number): number[] {
-        const range: number[] = [];
-
-        for (let i: number = 0; i < length; i++) {
-            range.push(i);
-        }
-
-        return range;
-    }
-
-    /**
-     * @param {number} length
-     * @param {(index: number) => TValue} valueFunction
-     * @returns {TValue[]}
-     */
-    public fillWithRange <TValue> (length: number, valueFunction: (index: number) => TValue): TValue[] {
-        const range: TValue[] = [];
-
-        for (let i: number = 0; i < length; i++) {
-            range.push(valueFunction(i));
-        }
-
-        return range;
-    }
-
-    /**
-     * @param {T[]} array
-     * @returns {T | null}
-     */
-    public findMostOccurringElement <T extends string | number> (array: T[]): T | null {
-        const arrayLength: number = array.length;
-
-        if (!arrayLength) {
-            return null;
-        }
-
-        const elementsMap: Partial<{[key in T]: number}> = {};
-
-        let mostOccurringElement: T = array[0];
-        let mostOccurringElementCount: number = 1;
-
-        for (const element of array) {
-            const currentElementCount: number = elementsMap[element] ?? 0;
-            const updatedElementCount: number = currentElementCount + 1;
-
-            if (updatedElementCount > mostOccurringElementCount) {
-                mostOccurringElement = element;
-                mostOccurringElementCount = updatedElementCount;
-            }
-
-            elementsMap[element] = updatedElementCount;
-        }
-
-        return mostOccurringElement;
-    }
-
-    /**
-     * @param {T[]} array
-     * @returns {T | undefined}
-     */
-    public getLastElement <T> (array: T[]): T | undefined {
-        const arrayLength: number = array.length;
-
-        return array[arrayLength - 1] ?? undefined;
-    }
-
-    /**
-     * @param {T[]} array
-     * @param {number} times
-     * @returns {T[]}
-     */
-    public rotate <T> (array: T[], times: number): T[] {
-        if (!array.length) {
-            throw new ReferenceError('Cannot rotate empty array.');
-        }
-
-        if (times <= 0) {
-            return array;
-        }
-
-        const newArray: T[] = array;
-
-        let temp: T | undefined;
-
-        while (times--) {
-            temp = newArray.pop();
-
-            if (temp) {
-                newArray.unshift(temp);
-            }
-        }
-
-        return newArray;
-    }
-
-    /**
-     * @param {T[]} array
-     * @returns {T[]}
-     */
-    public shuffle <T> (array: T[]): T[] {
-        const shuffledArray: T[] = [...array];
-
-        for (let i: number = shuffledArray.length; i; i--) {
-            const j: number = Math.floor(this.randomGenerator.getMathRandom() * i);
-
-            [shuffledArray[i - 1], shuffledArray[j]] = [shuffledArray[j], shuffledArray[i - 1]];
-        }
-
-        return shuffledArray;
-    }
-}

package/src/utils/CryptUtils.ts

@@ -1,149 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import { ICryptUtils } from '../interfaces/utils/ICryptUtils';
-import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
-
-import { base64alphabet } from '../constants/Base64Alphabet';
-
-import { RandomGenerator } from './RandomGenerator';
-import { Utils } from './Utils';
-
-@injectable()
-export class CryptUtils implements ICryptUtils {
-    /**
-     * @type {string}
-     */
-    protected readonly base64Alphabet: string = base64alphabet;
-
-    /**
-     * @type {IRandomGenerator}
-     */
-    private readonly randomGenerator: IRandomGenerator;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator
-    ) {
-        this.randomGenerator = randomGenerator;
-    }
-
-    /**
-     * @param {string} string
-     * @returns {string}
-     */
-    public btoa (string: string): string {
-        const chars: string = this.base64Alphabet;
-
-        let output: string = '';
-
-        string = encodeURIComponent(string).replace(/%([0-9A-F]{2})/g, (match: string, p1: string) => {
-            return String.fromCharCode(parseInt(`${Utils.hexadecimalPrefix}${p1}`, 16));
-        });
-
-        for (
-            let block: number | undefined, charCode: number, idx: number = 0, map: string = chars;
-            string.charAt(idx | 0) || (map = '=', idx % 1);
-            output += map.charAt(63 & block >> 8 - idx % 1 * 8)
-        ) {
-            charCode = string.charCodeAt(idx += 3/4);
-
-            if (charCode > 0xFF) {
-                throw new Error('\'btoa\' failed: The string to be encoded contains characters outside of the Latin1 range.');
-            }
-
-            block = <number>block << 8 | charCode;
-        }
-
-        return output;
-    }
-
-    /**
-     * Hides string inside a other random string with larger length
-     *
-     * @param {string} str
-     * @param {number} length
-     * @returns {[string , string]}
-     */
-    public hideString (str: string, length: number): [string, string] {
-        const escapeRegExp: (s: string) => string = (s: string) =>
-            s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
-
-        const randomMerge: (s1: string, s2: string) => string = (s1: string, s2: string): string => {
-            let i1: number = -1;
-            let i2: number = -1;
-            let result: string = '';
-
-            while (i1 < s1.length || i2 < s2.length) {
-                if (this.randomGenerator.getMathRandom() < 0.5 && i2 < s2.length) {
-                    result += s2.charAt(++i2);
-                } else {
-                    result += s1.charAt(++i1);
-                }
-            }
-
-            return result;
-        };
-
-        const randomString: string = this.randomGenerator.getRandomGenerator().string({
-            length: length,
-            pool: RandomGenerator.randomGeneratorPool
-        });
-
-        let randomStringDiff: string = randomString.replace(
-            new RegExp(`[${escapeRegExp(str)}]`, 'g'),
-            ''
-        );
-
-        const randomStringDiffArray: string[] = randomStringDiff.split('');
-
-        this.randomGenerator.getRandomGenerator().shuffle(randomStringDiffArray);
-        randomStringDiff = randomStringDiffArray.join('');
-
-        return [randomMerge(str, randomStringDiff), randomStringDiff];
-    }
-
-    /**
-     * RC4 symmetric cipher encryption/decryption
-     * https://gist.github.com/farhadi/2185197
-     *
-     * @param {string} string
-     * @param {string} key
-     * @returns {string}
-     */
-    public rc4 (string: string, key: string): string {
-        const s: number[] = [];
-
-        let j: number = 0;
-        let x: number;
-        let result: string = '';
-
-        // eslint-disable-next-line no-var
-        for (var i = 0; i < 256; i++) {
-            s[i] = i;
-        }
-
-        for (i = 0; i < 256; i++) {
-            j = (j + s[i] + key.charCodeAt(i % key.length)) % 256;
-            x = s[i];
-            s[i] = s[j];
-            s[j] = x;
-        }
-
-        i = 0;
-        j = 0;
-
-        for (let y = 0; y < string.length; y++) {
-            i = (i + 1) % 256;
-            j = (j + s[i]) % 256;
-            x = s[i];
-            s[i] = s[j];
-            s[j] = x;
-            result += String.fromCharCode(string.charCodeAt(y) ^ s[(s[i] + s[j]) % 256]);
-        }
-
-        return result;
-    }
-}

package/src/utils/CryptUtilsStringArray.ts

@@ -1,38 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../container/ServiceIdentifiers';
-
-import { ICryptUtilsStringArray } from '../interfaces/utils/ICryptUtilsStringArray';
-import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
-
-import { base64alphabetSwapped } from '../constants/Base64AlphabetSwapped';
-
-import { CryptUtils } from './CryptUtils';
-
-@injectable()
-export class CryptUtilsStringArray extends CryptUtils implements ICryptUtilsStringArray {
-    /**
-     * @type {string}
-     */
-    protected override readonly base64Alphabet: string = base64alphabetSwapped;
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator
-    ) {
-        super(randomGenerator);
-    }
-
-    /**
-     * Removes base64 encoded string without padding characters and with swapped alphabet
-     *
-     * @param {string} string
-     * @returns {string}
-     */
-    public override btoa (string: string): string {
-        const output = super.btoa(string);
-
-        return output.replace(/=+$/, '');
-    }
-}

package/src/utils/EscapeSequenceEncoder.ts

@@ -1,69 +0,0 @@
-import { injectable } from 'inversify';
-
-import { IEscapeSequenceEncoder } from '../interfaces/utils/IEscapeSequenceEncoder';
-
-@injectable()
-export class EscapeSequenceEncoder implements IEscapeSequenceEncoder {
-    /**
-     * https://bytefreaks.net/gnulinux/regular-expression-to-match-any-ascii-character
-     *
-     * @type {RegExp}
-     */
-    private static readonly ASCIICharactersRegExp: RegExp = /[\x00-\x7F]/;
-
-    /**
-     * https://en.wikipedia.org/wiki/List_of_Unicode_characters
-     * \x00-\x1F\x7F-\x9F are the control unicode characters
-     *
-     * @type {RegExp}
-     */
-    private static readonly forceEscapeCharactersRegExp: RegExp = /[\x00-\x1F\x7F-\x9F'"\\\s]/;
-
-    /**
-     * @type {Map<string, string>}
-     */
-    private readonly stringsCache: Map <string, string> = new Map();
-
-    /**
-     * @param {string} string
-     * @param {boolean} encodeAllSymbols
-     * @returns {string}
-     */
-    public encode (string: string, encodeAllSymbols: boolean): string {
-        const cacheKey: string = `${string}-${String(encodeAllSymbols)}`;
-
-        if (this.stringsCache.has(cacheKey)) {
-            return <string>this.stringsCache.get(cacheKey);
-        }
-
-        const radix: number = 16;
-        const replaceRegExp: RegExp = new RegExp('[\\s\\S]', 'g');
-
-        let prefix: string;
-        let template: string;
-
-        const result: string = string.replace(replaceRegExp, (character: string): string => {
-            const shouldEncodeCharacter: boolean = encodeAllSymbols
-                || EscapeSequenceEncoder.forceEscapeCharactersRegExp.test(character);
-
-            if (!shouldEncodeCharacter) {
-                return character;
-            }
-
-            if (EscapeSequenceEncoder.ASCIICharactersRegExp.test(character)) {
-                prefix = '\\x';
-                template = '00';
-            } else {
-                prefix = '\\u';
-                template = '0000';
-            }
-
-            return `${prefix}${(template + character.charCodeAt(0).toString(radix)).slice(-template.length)}`;
-        });
-
-        this.stringsCache.set(cacheKey, result);
-        this.stringsCache.set(`${result}-${String(encodeAllSymbols)}`, result);
-
-        return result;
-    }
-}