20001673109

Committed 07 Dec 2025 08:42AM UTC coverage: 95.728% (-1.6%) from 97.319%

Build # 20001673109

Build Type

push

github

Committed by

web-flow

Commit Message

Version 5.0.1 (#1344)

Run Details

1792 of 1970 branches covered (90.96%)

Branch coverage included in aggregate %.

57 of 68 new or added lines in 5 files covered. (83.82%)

4 existing lines in 1 file now uncovered.

5737 of 5895 relevant lines covered (97.32%)

33531693.24 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.56

/src/JavaScriptObfuscatorFacade.ts

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 { IProApiConfig, IProObfuscationResult, TProApiProgressCallback } from './interfaces/pro-api/IProApiClient';
import { ApiError } from './pro-api/ApiError';

import { InversifyContainerFacade } from './container/InversifyContainerFacade';
import { Options } from './options/Options';
import { Utils } from './utils/Utils';
import { ProApiClient } from './pro-api/ProApiClient';

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);
    }

    /**
     * Obfuscate code using the Pro API (obfuscator.io)
     * This method requires a valid API token from obfuscator.io and only works with VM obfuscation.
     *
     * @param {string} sourceCode - Source code to obfuscate
     * @param {TInputOptions} inputOptions - Obfuscation options (must include vmObfuscation: true)
     * @param {IProApiConfig} proApiConfig - Pro API configuration including API token
     * @param {TProApiProgressCallback} onProgress - Optional callback for progress updates (streaming mode only)
     * @returns {Promise<IProObfuscationResult>} - Promise resolving to obfuscation result
     * @throws {ApiError} - If API returns an error or vmObfuscation is not enabled
     */
    public static async obfuscatePro(
        sourceCode: string,
        inputOptions: TInputOptions,
        proApiConfig: IProApiConfig,
        onProgress?: TProApiProgressCallback
    ): Promise<IProObfuscationResult> {
        if (!inputOptions.vmObfuscation) {
            throw new ApiError(
                'obfuscatePro method works only with VM obfuscation. Set vmObfuscation: true in options.',
                400
            );
        }

        const client = new ProApiClient(proApiConfig);

        return client.obfuscate(sourceCode, inputOptions, onProgress);
    }
}

export { JavaScriptObfuscatorFacade as JavaScriptObfuscator };
export { ApiError } from './pro-api/ApiError';
export type { IProApiConfig, TProApiProgressCallback } from './interfaces/pro-api/IProApiClient';

1	import 'reflect-metadata';	6✔
2
3	import { ServiceIdentifiers } from './container/ServiceIdentifiers';	6✔
4
5	import { TDictionary } from './types/TDictionary';
6	import { TInputOptions } from './types/options/TInputOptions';
7	import { TObfuscationResultsObject } from './types/TObfuscationResultsObject';
8	import { TOptionsPreset } from './types/options/TOptionsPreset';
9
10	import { IInversifyContainerFacade } from './interfaces/container/IInversifyContainerFacade';
11	import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
12	import { IObfuscationResult } from './interfaces/source-code/IObfuscationResult';
13	import { IProApiConfig, IProObfuscationResult, TProApiProgressCallback } from './interfaces/pro-api/IProApiClient';
14	import { ApiError } from './pro-api/ApiError';	6✔
15
16	import { InversifyContainerFacade } from './container/InversifyContainerFacade';	6✔
17	import { Options } from './options/Options';	6✔
18	import { Utils } from './utils/Utils';	6✔
19	import { ProApiClient } from './pro-api/ProApiClient';	6✔
20
21	class JavaScriptObfuscatorFacade {
22	/**
23	* @type {string \| undefined}
24	*/
25	public static version: string = process.env.VERSION ?? 'unknown';	6!
26
27	/**
28	* @param {string} sourceCode
29	* @param {TInputOptions} inputOptions
30	* @returns {IObfuscationResult}
31	*/
32	public static obfuscate(sourceCode: string, inputOptions: TInputOptions = {}): IObfuscationResult {	3,036✔
33	const inversifyContainerFacade: IInversifyContainerFacade = new InversifyContainerFacade();	197,706✔
34
35	inversifyContainerFacade.load(sourceCode, '', inputOptions);	197,706✔
36
37	const javaScriptObfuscator: IJavaScriptObfuscator = inversifyContainerFacade.get<IJavaScriptObfuscator>(	197,706✔
38	ServiceIdentifiers.IJavaScriptObfuscator
39	);
40	const obfuscationResult: IObfuscationResult = javaScriptObfuscator.obfuscate(sourceCode);	197,640✔
41
42	inversifyContainerFacade.unload();	197,634✔
43
44	return obfuscationResult;	197,634✔
45	}
46
47	/**
48	* @param {TSourceCodesObject} sourceCodesObject
49	* @param {TInputOptions} inputOptions
50	* @returns {TObfuscationResultsObject<TSourceCodesObject>}
51	*/
52	public static obfuscateMultiple<TSourceCodesObject extends TDictionary<string>>(
53	sourceCodesObject: TSourceCodesObject,
54	inputOptions: TInputOptions = {}	×
55	): TObfuscationResultsObject<TSourceCodesObject> {
56	if (typeof sourceCodesObject !== 'object') {	18✔
57	throw new Error('Source codes object should be a plain object');	6✔
58	}
59
60	return Object.keys(sourceCodesObject).reduce(	12✔
61	(
62	acc: TObfuscationResultsObject<TSourceCodesObject>,
63	sourceCodeIdentifier: keyof TSourceCodesObject,
64	index: number
65	) => {
66	const identifiersPrefix: string = Utils.getIdentifiersPrefixForMultipleSources(	24✔
67	inputOptions.identifiersPrefix,
68	index
69	);
70
71	const sourceCode: string = sourceCodesObject[sourceCodeIdentifier];	24✔
72	const sourceCodeOptions: TInputOptions = {	24✔
73	...inputOptions,
74	identifiersPrefix
75	};
76
77	return {	24✔
78	...acc,
79	[sourceCodeIdentifier]: JavaScriptObfuscatorFacade.obfuscate(sourceCode, sourceCodeOptions)
80	};
81	},
82	<TObfuscationResultsObject<TSourceCodesObject>>{}
83	);
84	}
85
86	/**
87	* @param {TOptionsPreset} optionsPreset
88	* @returns {TInputOptions}
89	*/
90	public static getOptionsByPreset(optionsPreset: TOptionsPreset): TInputOptions {
91	return Options.getOptionsByPreset(optionsPreset);	12✔
92	}
93
94	/**
95	* Obfuscate code using the Pro API (obfuscator.io)
96	* This method requires a valid API token from obfuscator.io and only works with VM obfuscation.
97	*
98	* @param {string} sourceCode - Source code to obfuscate
99	* @param {TInputOptions} inputOptions - Obfuscation options (must include vmObfuscation: true)
100	* @param {IProApiConfig} proApiConfig - Pro API configuration including API token
101	* @param {TProApiProgressCallback} onProgress - Optional callback for progress updates (streaming mode only)
102	* @returns {Promise<IProObfuscationResult>} - Promise resolving to obfuscation result
103	* @throws {ApiError} - If API returns an error or vmObfuscation is not enabled
104	*/
105	public static async obfuscatePro(
106	sourceCode: string,
107	inputOptions: TInputOptions,
108	proApiConfig: IProApiConfig,
109	onProgress?: TProApiProgressCallback
110	): Promise<IProObfuscationResult> {
UNCOV 111	if (!inputOptions.vmObfuscation) {	×
UNCOV 112	throw new ApiError(	×
113	'obfuscatePro method works only with VM obfuscation. Set vmObfuscation: true in options.',
114	400
115	);
116	}
117
UNCOV 118	const client = new ProApiClient(proApiConfig);	×
119
UNCOV 120	return client.obfuscate(sourceCode, inputOptions, onProgress);	×
121	}
122	}
123
124	export { JavaScriptObfuscatorFacade as JavaScriptObfuscator };	6✔
125	export { ApiError } from './pro-api/ApiError';	6✔
126	export type { IProApiConfig, TProApiProgressCallback } from './interfaces/pro-api/IProApiClient';

javascript-obfuscator / javascript-obfuscator / 20001673109

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous