javascript-obfuscator 2.18.0 → 3.0.0

package/typings/src/node-transformers/simplifying-transformers/BlockStatementSimplifyTransformer.d.ts

@@ -0,0 +1,13 @@
+import * as ESTree from 'estree';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { AbstractStatementSimplifyTransformer } from './AbstractStatementSimplifyTransformer';
+export declare class BlockStatementSimplifyTransformer extends AbstractStatementSimplifyTransformer {
+    readonly runAfter: NodeTransformer[];
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    transformNode(statementNode: ESTree.Statement, parentNode: ESTree.Node): ESTree.Node;
+}

package/typings/src/node-transformers/simplifying-transformers/ExpressionStatementsMergeTransformer.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="estraverse" />
+import * as estraverse from '@javascript-obfuscator/estraverse';
+import * as ESTree from 'estree';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+export declare class ExpressionStatementsMergeTransformer extends AbstractNodeTransformer {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    transformNode(expressionStatementNode: ESTree.ExpressionStatement, parentNode: ESTree.Node): ESTree.ExpressionStatement | estraverse.VisitorOption;
+}

package/typings/src/node-transformers/simplifying-transformers/IfStatementSimplifyTransformer.d.ts

@@ -0,0 +1,16 @@
+import * as ESTree from 'estree';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStatementSimplifyData } from '../../interfaces/node-transformers/simplifying-transformers/IStatementSimplifyData';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { AbstractStatementSimplifyTransformer } from './AbstractStatementSimplifyTransformer';
+export declare class IfStatementSimplifyTransformer extends AbstractStatementSimplifyTransformer {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    transformNode(ifStatementNode: ESTree.IfStatement, parentNode: ESTree.Node): ESTree.Node;
+    protected getConsequentNode(ifStatementNode: ESTree.IfStatement, consequentSimplifyData: IStatementSimplifyData): ESTree.Node;
+    protected getConsequentAndAlternateNode(ifStatementNode: ESTree.IfStatement, consequentSimplifyData: IStatementSimplifyData, alternateSimplifyData: IStatementSimplifyData): ESTree.Node;
+    protected getPartialStatement(statementSimplifyData: IStatementSimplifyData): ESTree.Statement;
+    protected isProhibitedSingleStatementForIfStatementBranch(statement: ESTree.Statement): boolean;
+}

package/typings/src/node-transformers/simplifying-transformers/VariableDeclarationsMergeTransformer.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="estraverse" />
+import * as estraverse from '@javascript-obfuscator/estraverse';
+import * as ESTree from 'estree';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+export declare class VariableDeclarationsMergeTransformer extends AbstractNodeTransformer {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    transformNode(variableDeclarationNode: ESTree.VariableDeclaration, parentNode: ESTree.Node): ESTree.VariableDeclaration | estraverse.VisitorOption;
+}

package/typings/src/node-transformers/string-array-transformers/StringArrayRotateFunctionTransformer.d.ts

@@ -0,0 +1,27 @@
+import * as ESTree from 'estree';
+import { TCustomCodeHelperFactory } from '../../types/container/custom-code-helpers/TCustomCodeHelperFactory';
+import { INodeTransformersRunner } from '../../interfaces/node-transformers/INodeTransformersRunner';
+import { INumberNumericalExpressionAnalyzer } from '../../interfaces/analyzers/number-numerical-expression-analyzer/INumberNumericalExpressionAnalyzer';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { IStringArrayStorageAnalyzer } from '../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+export declare class StringArrayRotateFunctionTransformer extends AbstractNodeTransformer {
+    private static readonly stringArrayRotateFunctionTransformers;
+    private static readonly comparisonExpressionAdditionalPartsCount;
+    private readonly numberNumericalExpressionAnalyzer;
+    private readonly stringArrayStorage;
+    private readonly stringArrayStorageAnalyzer;
+    private readonly customCodeHelperFactory;
+    private readonly transformersRunner;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions, transformersRunner: INodeTransformersRunner, stringArrayStorage: IStringArrayStorage, stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer, customCodeHelperFactory: TCustomCodeHelperFactory, numberNumericalExpressionAnalyzer: INumberNumericalExpressionAnalyzer);
+    private static isProgramNodeHasStringLiterals;
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    transformNode(programNode: ESTree.Program): ESTree.Node;
+    private getStringArrayRotateFunctionNode;
+    private isComparisonExpressionStringLiteralNode;
+    private getComparisonValue;
+}

package/typings/src/node-transformers/string-array-transformers/StringArrayScopeCallsWrapperTransformer.d.ts

@@ -0,0 +1,28 @@
+import { TNodeWithLexicalScopeStatements } from '../../types/node/TNodeWithLexicalScopeStatements';
+import { TStringArrayCustomNodeFactory } from '../../types/container/custom-nodes/TStringArrayCustomNodeFactory';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayScopeCallsWrappersDataStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrappersDataStorage';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { IVisitedLexicalScopeNodesStackStorage } from '../../interfaces/storages/string-array-transformers/IVisitedLexicalScopeNodesStackStorage';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+export declare class StringArrayScopeCallsWrapperTransformer extends AbstractNodeTransformer {
+    readonly runAfter: NodeTransformer[];
+    private readonly stringArrayStorage;
+    private readonly stringArrayScopeCallsWrappersDataStorage;
+    private readonly stringArrayTransformerCustomNodeFactory;
+    private readonly visitedLexicalScopeNodesStackStorage;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions, visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage, stringArrayStorage: IStringArrayStorage, stringArrayScopeCallsWrappersDataStorage: IStringArrayScopeCallsWrappersDataStorage, stringArrayTransformerCustomNodeFactory: TStringArrayCustomNodeFactory);
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    transformNode(lexicalScopeBodyNode: TNodeWithLexicalScopeStatements): TNodeWithLexicalScopeStatements;
+    private getRootStringArrayCallsWrapperData;
+    private getUpperStringArrayCallsWrapperData;
+    private getAndAppendStringArrayScopeCallsWrapperNode;
+    private getStringArrayScopeCallsWrapperVariableNode;
+    private getStringArrayScopeCallsWrapperFunctionNode;
+    private onLexicalScopeNodeEnter;
+    private onLexicalScopeNodeLeave;
+}

package/typings/src/node-transformers/string-array-transformers/StringArrayTransformer.d.ts

@@ -0,0 +1,37 @@
+import * as ESTree from 'estree';
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStringArrayCustomNodeFactory } from '../../types/container/custom-nodes/TStringArrayCustomNodeFactory';
+import { ILiteralNodesCacheStorage } from '../../interfaces/storages/string-array-transformers/ILiteralNodesCacheStorage';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayScopeCallsWrappersDataStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrappersDataStorage';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { IStringArrayStorageAnalyzer } from '../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
+import { IVisitedLexicalScopeNodesStackStorage } from '../../interfaces/storages/string-array-transformers/IVisitedLexicalScopeNodesStackStorage';
+import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
+export declare class StringArrayTransformer extends AbstractNodeTransformer {
+    private static readonly minShiftedIndexValue;
+    private static readonly maxShiftedIndexValue;
+    readonly runAfter: NodeTransformer[];
+    private readonly identifierNamesGenerator;
+    private readonly literalNodesCacheStorage;
+    private readonly stringArrayStorage;
+    private readonly stringArrayStorageAnalyzer;
+    private readonly stringArrayScopeCallsWrappersDataStorage;
+    private readonly stringArrayTransformerCustomNodeFactory;
+    private readonly visitedLexicalScopeNodesStackStorage;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions, literalNodesCacheStorage: ILiteralNodesCacheStorage, visitedLexicalScopeNodesStackStorage: IVisitedLexicalScopeNodesStackStorage, stringArrayStorage: IStringArrayStorage, stringArrayScopeCallsWrappersDataStorage: IStringArrayScopeCallsWrappersDataStorage, stringArrayStorageAnalyzer: IStringArrayStorageAnalyzer, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, stringArrayTransformerCustomNodeFactory: TStringArrayCustomNodeFactory);
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    prepareNode(programNode: ESTree.Program): void;
+    transformNode(literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node;
+    private getStringArrayCallNode;
+    private getStringArrayScopeCallsWrapperData;
+    private getRootStringArrayScopeCallsWrapperData;
+    private getUpperStringArrayScopeCallsWrapperData;
+    private getAndUpdateStringArrayScopeCallsWrappersDataByEncoding;
+    private getStringArrayCallsWrapperShiftedIndex;
+    private getStringArrayCallsWrapperParameterIndexesData;
+}

package/typings/src/options/Options.d.ts

@@ -0,0 +1,69 @@
+import { TIdentifierNamesCache } from '../types/TIdentifierNamesCache';
+import { TInputOptions } from '../types/options/TInputOptions';
+import { TOptionsPreset } from '../types/options/TOptionsPreset';
+import { TRenamePropertiesMode } from '../types/options/TRenamePropertiesMode';
+import { TStringArrayIndexesType } from '../types/options/TStringArrayIndexesType';
+import { TStringArrayEncoding } from '../types/options/TStringArrayEncoding';
+import { TStringArrayWrappersType } from '../types/options/TStringArrayWrappersType';
+import { TTypeFromEnum } from '../types/utils/TTypeFromEnum';
+import { IOptions } from '../interfaces/options/IOptions';
+import { IOptionsNormalizer } from '../interfaces/options/IOptionsNormalizer';
+import { IdentifierNamesGenerator } from '../enums/generators/identifier-names-generators/IdentifierNamesGenerator';
+import { ObfuscationTarget } from '../enums/ObfuscationTarget';
+import { SourceMapMode } from '../enums/source-map/SourceMapMode';
+import { SourceMapSourcesMode } from '../enums/source-map/SourceMapSourcesMode';
+export declare class Options implements IOptions {
+    private static readonly optionPresetsMap;
+    private static readonly validatorOptions;
+    readonly compact: boolean;
+    readonly controlFlowFlattening: boolean;
+    readonly controlFlowFlatteningThreshold: number;
+    readonly deadCodeInjection: boolean;
+    readonly deadCodeInjectionThreshold: number;
+    readonly debugProtection: boolean;
+    readonly debugProtectionInterval: boolean;
+    readonly disableConsoleOutput: boolean;
+    readonly domainLock: string[];
+    readonly domainLockRedirectUrl: string;
+    readonly forceTransformStrings: string[];
+    readonly identifierNamesCache: TIdentifierNamesCache;
+    readonly identifierNamesGenerator: TTypeFromEnum<typeof IdentifierNamesGenerator>;
+    readonly identifiersPrefix: string;
+    readonly identifiersDictionary: string[];
+    readonly ignoreImports: boolean;
+    readonly inputFileName: string;
+    readonly log: boolean;
+    readonly numbersToExpressions: boolean;
+    readonly optionsPreset: TOptionsPreset;
+    readonly renameGlobals: boolean;
+    readonly renameProperties: boolean;
+    readonly renamePropertiesMode: TRenamePropertiesMode;
+    readonly reservedNames: string[];
+    readonly reservedStrings: string[];
+    readonly selfDefending: boolean;
+    readonly simplify: boolean;
+    readonly sourceMap: boolean;
+    readonly sourceMapBaseUrl: string;
+    readonly sourceMapFileName: string;
+    readonly sourceMapMode: TTypeFromEnum<typeof SourceMapMode>;
+    readonly sourceMapSourcesMode: TTypeFromEnum<typeof SourceMapSourcesMode>;
+    readonly splitStrings: boolean;
+    readonly splitStringsChunkLength: number;
+    readonly stringArray: boolean;
+    readonly stringArrayEncoding: TStringArrayEncoding[];
+    readonly stringArrayIndexesType: TStringArrayIndexesType[];
+    readonly stringArrayIndexShift: boolean;
+    readonly stringArrayRotate: boolean;
+    readonly stringArrayShuffle: boolean;
+    readonly stringArrayWrappersChainedCalls: boolean;
+    readonly stringArrayWrappersCount: number;
+    readonly stringArrayWrappersParametersMaxCount: number;
+    readonly stringArrayWrappersType: TStringArrayWrappersType;
+    readonly stringArrayThreshold: number;
+    readonly target: TTypeFromEnum<typeof ObfuscationTarget>;
+    readonly transformObjectKeys: boolean;
+    readonly unicodeEscapeSequence: boolean;
+    readonly seed: string | number;
+    constructor(inputOptions: TInputOptions, optionsNormalizer: IOptionsNormalizer);
+    static getOptionsByPreset(optionsPreset: TOptionsPreset): TInputOptions;
+}

package/typings/src/options/OptionsNormalizer.d.ts

@@ -0,0 +1,6 @@
+import { IOptions } from '../interfaces/options/IOptions';
+import { IOptionsNormalizer } from '../interfaces/options/IOptionsNormalizer';
+export declare class OptionsNormalizer implements IOptionsNormalizer {
+    private static readonly normalizerRules;
+    normalize(options: IOptions): IOptions;
+}

package/typings/src/options/ValidationErrorsFormatter.d.ts

@@ -0,0 +1,5 @@
+import { ValidationError } from 'class-validator';
+export declare class ValidationErrorsFormatter {
+    static format(errors: ValidationError[]): string;
+    private static formatWithNestedConstraints;
+}

package/typings/src/options/normalizer-rules/ControlFlowFlatteningThresholdRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const ControlFlowFlatteningThresholdRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/DeadCodeInjectionRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const DeadCodeInjectionRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/DeadCodeInjectionThresholdRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const DeadCodeInjectionThresholdRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/DomainLockRedirectUrlRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const DomainLockRedirectUrlRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/DomainLockRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const DomainLockRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/IdentifierNamesCacheRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const IdentifierNamesCacheRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/InputFileNameRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const InputFileNameRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/SeedRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const SeedRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/SelfDefendingRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const SelfDefendingRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/SourceMapBaseUrlRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const SourceMapBaseUrlRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/SourceMapFileNameRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const SourceMapFileNameRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/SplitStringsChunkLengthRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const SplitStringsChunkLengthRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/StringArrayEncodingRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const StringArrayEncodingRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/StringArrayRule.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const StringArrayRule: TOptionsNormalizerRule;

package/typings/src/options/normalizer-rules/StringArrayWappersChainedCalls.d.ts

@@ -0,0 +1,2 @@
+import { TOptionsNormalizerRule } from '../../types/options/TOptionsNormalizerRule';
+export declare const StringArrayWrappersChainedCallsRule: TOptionsNormalizerRule;

package/typings/src/options/presets/Default.d.ts

@@ -0,0 +1,2 @@
+import { TInputOptions } from '../../types/options/TInputOptions';
+export declare const DEFAULT_PRESET: TInputOptions;

package/typings/src/options/presets/HighObfuscation.d.ts

@@ -0,0 +1,2 @@
+import { TInputOptions } from '../../types/options/TInputOptions';
+export declare const HIGH_OBFUSCATION_PRESET: TInputOptions;

package/typings/src/options/presets/LowObfuscation.d.ts

@@ -0,0 +1,2 @@
+import { TInputOptions } from '../../types/options/TInputOptions';
+export declare const LOW_OBFUSCATION_PRESET: TInputOptions;

package/typings/src/options/presets/MediumObfuscation.d.ts

@@ -0,0 +1,2 @@
+import { TInputOptions } from '../../types/options/TInputOptions';
+export declare const MEDIUM_OBFUSCATION_PRESET: TInputOptions;

package/typings/src/options/presets/NoCustomNodes.d.ts

@@ -0,0 +1,2 @@
+import { TInputOptions } from '../../types/options/TInputOptions';
+export declare const NO_ADDITIONAL_NODES_PRESET: TInputOptions;

package/typings/src/options/validators/IsAllowedForObfuscationTargets.d.ts

@@ -0,0 +1,5 @@
+import { ValidationOptions } from 'class-validator';
+import { TTypeFromEnum } from '../../types/utils/TTypeFromEnum';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { ObfuscationTarget } from '../../enums/ObfuscationTarget';
+export declare function IsAllowedForObfuscationTargets(obfuscationTargets: TTypeFromEnum<typeof ObfuscationTarget>[], validationOptions?: ValidationOptions): (options: IOptions, propertyName: keyof IOptions) => void;

package/typings/src/options/validators/IsDomainLockRedirectUrl.d.ts

@@ -0,0 +1 @@
+export declare const IsDomainLockRedirectUrl: () => PropertyDecorator;

package/typings/src/options/validators/IsIdentifierNamesCache.d.ts

@@ -0,0 +1,3 @@
+import { ValidationOptions } from 'class-validator';
+import { IOptions } from '../../interfaces/options/IOptions';
+export declare function IsIdentifierNamesCache(validationOptions?: ValidationOptions): (options: IOptions, propertyName: keyof IOptions) => void;

package/typings/src/options/validators/IsInputFileName.d.ts

@@ -0,0 +1 @@
+export declare const IsInputFileName: () => PropertyDecorator;

package/typings/src/source-code/ObfuscationResult.d.ts

@@ -0,0 +1,22 @@
+import { TIdentifierNamesCache } from '../types/TIdentifierNamesCache';
+import { ICryptUtils } from '../interfaces/utils/ICryptUtils';
+import { IGlobalIdentifierNamesCacheStorage } from '../interfaces/storages/identifier-names-cache/IGlobalIdentifierNamesCacheStorage';
+import { IObfuscationResult } from '../interfaces/source-code/IObfuscationResult';
+import { IPropertyIdentifierNamesCacheStorage } from '../interfaces/storages/identifier-names-cache/IPropertyIdentifierNamesCacheStorage';
+import { IOptions } from '../interfaces/options/IOptions';
+export declare class ObfuscationResult implements IObfuscationResult {
+    private obfuscatedCode;
+    private sourceMap;
+    private readonly cryptUtils;
+    private readonly globalIdentifierNamesCacheStorage;
+    private readonly propertyIdentifierNamesCacheStorage;
+    private readonly options;
+    constructor(cryptUtils: ICryptUtils, globalIdentifierNamesCacheStorage: IGlobalIdentifierNamesCacheStorage, propertyIdentifierNamesCacheStorage: IPropertyIdentifierNamesCacheStorage, options: IOptions);
+    initialize(obfuscatedCode: string, sourceMap: string): void;
+    getIdentifierNamesCache(): TIdentifierNamesCache;
+    getObfuscatedCode(): string;
+    getOptions(): IOptions;
+    getSourceMap(): string;
+    toString(): string;
+    private correctObfuscatedCode;
+}

package/typings/src/source-code/SourceCode.d.ts

@@ -0,0 +1,9 @@
+import { ISourceCode } from '../interfaces/source-code/ISourceCode';
+export declare class SourceCode implements ISourceCode {
+    private readonly sourceCode;
+    private readonly sourceMap;
+    constructor(sourceCode: string, sourceMap: string);
+    getSourceCode(): string;
+    getSourceMap(): string;
+    toString(): string;
+}

package/typings/src/storages/ArrayStorage.d.ts

@@ -0,0 +1,21 @@
+import { IArrayStorage } from '../interfaces/storages/IArrayStorage';
+import { IOptions } from '../interfaces/options/IOptions';
+import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
+export declare abstract class ArrayStorage<V> implements IArrayStorage<V> {
+    protected storage: V[];
+    protected storageId: string;
+    protected readonly randomGenerator: IRandomGenerator;
+    protected readonly options: IOptions;
+    private storageLength;
+    protected constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(): void;
+    delete(key: number): V | undefined;
+    get(key: number): V | undefined;
+    getOrThrow(key: number): V;
+    getKeyOf(value: V): number | null;
+    getLength(): number;
+    getStorage(): V[];
+    getStorageId(): string;
+    mergeWith(storage: this, mergeId?: boolean): void;
+    set(key: number, value: V): void;
+}

package/typings/src/storages/MapStorage.d.ts

@@ -0,0 +1,22 @@
+import { IMapStorage } from '../interfaces/storages/IMapStorage';
+import { IOptions } from '../interfaces/options/IOptions';
+import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
+import { TDictionary } from '../types/TDictionary';
+export declare abstract class MapStorage<K, V> implements IMapStorage<K, V> {
+    protected storageId: string;
+    protected storage: Map<K, V>;
+    protected readonly options: IOptions;
+    protected readonly randomGenerator: IRandomGenerator;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(): void;
+    get(key: K): V | undefined;
+    getOrThrow(key: K): V;
+    getKeyOf(value: V): K | null;
+    getLength(): number;
+    getStorage(): Map<K, V>;
+    getStorageAsDictionary(): TDictionary<V>;
+    getStorageId(): string;
+    has(key: K): boolean;
+    mergeWith(storage: this, mergeId?: boolean): void;
+    set(key: K, value: V): void;
+}

package/typings/src/storages/custom-code-helpers/CustomCodeHelperGroupStorage.d.ts

@@ -0,0 +1,11 @@
+import { TCustomCodeHelperGroupFactory } from '../../types/container/custom-code-helpers/TCustomCodeHelperGroupFactory';
+import { ICustomCodeHelperGroup } from '../../interfaces/custom-code-helpers/ICustomCodeHelperGroup';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { MapStorage } from '../MapStorage';
+export declare class CustomCodeHelperGroupStorage extends MapStorage<string, ICustomCodeHelperGroup> {
+    private static readonly customCodeHelperGroupsList;
+    private readonly customCodeHelperGroupFactory;
+    constructor(customCodeHelperGroupFactory: TCustomCodeHelperGroupFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(): void;
+}

package/typings/src/storages/custom-nodes/ControlFlowStorage.d.ts

@@ -0,0 +1,7 @@
+import { ICustomNode } from '../../interfaces/custom-nodes/ICustomNode';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { MapStorage } from '../MapStorage';
+export declare class ControlFlowStorage extends MapStorage<string, ICustomNode> {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+}

package/typings/src/storages/identifier-names-cache/GlobalIdentifierNamesCacheStorage.d.ts

@@ -0,0 +1,8 @@
+import { IGlobalIdentifierNamesCacheStorage } from '../../interfaces/storages/identifier-names-cache/IGlobalIdentifierNamesCacheStorage';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { MapStorage } from '../MapStorage';
+export declare class GlobalIdentifierNamesCacheStorage extends MapStorage<string, string> implements IGlobalIdentifierNamesCacheStorage {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(): void;
+}

package/typings/src/storages/identifier-names-cache/PropertyIdentifierNamesCacheStorage.d.ts

@@ -0,0 +1,8 @@
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IPropertyIdentifierNamesCacheStorage } from '../../interfaces/storages/identifier-names-cache/IPropertyIdentifierNamesCacheStorage';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { MapStorage } from '../MapStorage';
+export declare class PropertyIdentifierNamesCacheStorage extends MapStorage<string, string> implements IPropertyIdentifierNamesCacheStorage {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(): void;
+}

package/typings/src/storages/string-array-transformers/LiteralNodesCacheStorage.d.ts

@@ -0,0 +1,11 @@
+import * as ESTree from 'estree';
+import { ILiteralNodesCacheStorage } from '../../interfaces/storages/string-array-transformers/ILiteralNodesCacheStorage';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayStorageItemData } from '../../interfaces/storages/string-array-transformers/IStringArrayStorageItem';
+import { MapStorage } from '../MapStorage';
+export declare class LiteralNodesCacheStorage extends MapStorage<string, ESTree.Node> implements ILiteralNodesCacheStorage {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    buildKey(literalValue: string, stringArrayStorageItemData: IStringArrayStorageItemData | undefined): string;
+    shouldUseCachedValue(key: string, stringArrayStorageItemData: IStringArrayStorageItemData | undefined): boolean;
+}

package/typings/src/storages/string-array-transformers/StringArrayScopeCallsWrappersDataStorage.d.ts

@@ -0,0 +1,9 @@
+import { TNodeWithLexicalScopeStatements } from '../../types/node/TNodeWithLexicalScopeStatements';
+import { TStringArrayScopeCallsWrappersDataByEncoding } from '../../types/node-transformers/string-array-transformers/TStringArrayScopeCallsWrappersDataByEncoding';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayScopeCallsWrappersDataStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrappersDataStorage';
+import { MapStorage } from '../MapStorage';
+export declare class StringArrayScopeCallsWrappersDataStorage extends MapStorage<TNodeWithLexicalScopeStatements, TStringArrayScopeCallsWrappersDataByEncoding> implements IStringArrayScopeCallsWrappersDataStorage {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+}

package/typings/src/storages/string-array-transformers/StringArrayStorage.d.ts

@@ -0,0 +1,39 @@
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStringArrayEncoding } from '../../types/options/TStringArrayEncoding';
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+import { ICryptUtilsStringArray } from '../../interfaces/utils/ICryptUtilsStringArray';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { IStringArrayStorageItemData } from '../../interfaces/storages/string-array-transformers/IStringArrayStorageItem';
+import { MapStorage } from '../MapStorage';
+export declare class StringArrayStorage extends MapStorage<`${string}-${TStringArrayEncoding}`, IStringArrayStorageItemData> implements IStringArrayStorage {
+    private static readonly minimumRotationAmount;
+    private static readonly maximumRotationAmount;
+    private static readonly minimumIndexShiftAmount;
+    private static readonly maximumIndexShiftAmount;
+    private static readonly rc4KeyLength;
+    private static readonly rc4KeysCount;
+    private static readonly stringArrayFunctionNameLength;
+    private readonly arrayUtils;
+    private readonly cryptUtilsStringArray;
+    private readonly identifierNamesGenerator;
+    private readonly rc4Keys;
+    private readonly rc4EncodedValuesSourcesCache;
+    private indexShiftAmount;
+    private rotationAmount;
+    private stringArrayStorageName;
+    private readonly stringArrayStorageCallsWrapperNamesMap;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions, cryptUtilsStringArray: ICryptUtilsStringArray);
+    initialize(): void;
+    get(value: string): IStringArrayStorageItemData;
+    getIndexShiftAmount(): number;
+    getRotationAmount(): number;
+    getStorageName(): string;
+    getStorageId(): string;
+    getStorageCallsWrapperName(stringArrayEncoding: TStringArrayEncoding | null): string;
+    rotateStorage(): void;
+    shuffleStorage(): void;
+    private getOrSetIfDoesNotExist;
+    private getEncodedValue;
+}

package/typings/src/storages/string-array-transformers/VisitedLexicalScopeNodesStackStorage.d.ts

@@ -0,0 +1,14 @@
+import { TNodeWithLexicalScopeStatements } from '../../types/node/TNodeWithLexicalScopeStatements';
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IVisitedLexicalScopeNodesStackStorage } from '../../interfaces/storages/string-array-transformers/IVisitedLexicalScopeNodesStackStorage';
+import { ArrayStorage } from '../ArrayStorage';
+export declare class VisitedLexicalScopeNodesStackStorage extends ArrayStorage<TNodeWithLexicalScopeStatements> implements IVisitedLexicalScopeNodesStackStorage {
+    private readonly arrayUtils;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions, arrayUtils: IArrayUtils);
+    getLastElement(): TNodeWithLexicalScopeStatements | undefined;
+    getPenultimateElement(): TNodeWithLexicalScopeStatements | undefined;
+    push(nodeWithLexicalScopeStatements: TNodeWithLexicalScopeStatements): void;
+    pop(): TNodeWithLexicalScopeStatements | undefined;
+}

package/typings/src/types/TDictionary.d.ts

@@ -0,0 +1,3 @@
+export declare type TDictionary<T = unknown> = {
+    [key: string]: T;
+};

package/{src/types/TIdentifierNamesCache.ts → typings/src/types/TIdentifierNamesCache.d.ts}

@@ -1,7 +1,5 @@
 import { TIdentifierNamesCacheDictionary } from './TIdentifierNamesCacheDictionary';
-
-export type TIdentifierNamesCache = {
+export declare type TIdentifierNamesCache = {
     globalIdentifiers?: TIdentifierNamesCacheDictionary;
     propertyIdentifiers?: TIdentifierNamesCacheDictionary;
 } | null;
-

package/typings/src/types/TIdentifierNamesCacheDictionary.d.ts

@@ -0,0 +1,2 @@
+import { TDictionary } from './TDictionary';
+export declare type TIdentifierNamesCacheDictionary = TDictionary<string>;

package/typings/src/types/TInitialData.d.ts

@@ -0,0 +1,2 @@
+import { IInitializable } from '../interfaces/IInitializable';
+export declare type TInitialData<TClass extends IInitializable> = Parameters<TClass['initialize']>;

package/typings/src/types/TObfuscationResultsObject.d.ts

@@ -0,0 +1,4 @@
+import { IObfuscationResult } from '../interfaces/source-code/IObfuscationResult';
+export declare type TObfuscationResultsObject<TSourceCodesObject> = {
+    [key in keyof TSourceCodesObject]: IObfuscationResult;
+};

package/typings/src/types/analyzers/calls-graph-analyzer/TObjectMembersCallsChain.d.ts

@@ -0,0 +1 @@
+export declare type TObjectMembersCallsChain = (string | number)[];

package/typings/src/types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData.d.ts

@@ -0,0 +1 @@
+export declare type TNumberNumericalExpressionData = (number | number[])[];

package/typings/src/types/cli/TCLISanitizer.d.ts

@@ -0,0 +1 @@
+export declare type TCLISanitizer<T> = (value: string) => T;

package/{src/types/container/calls-graph-analyzer/TCalleeDataExtractorFactory.ts → typings/src/types/container/calls-graph-analyzer/TCalleeDataExtractorFactory.d.ts}

@@ -1,5 +1,3 @@
 import { ICalleeDataExtractor } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeDataExtractor';
-
 import { CalleeDataExtractor } from '../../../enums/analyzers/calls-graph-analyzer/CalleeDataExtractor';
-
-export type TCalleeDataExtractorFactory = (calleeDataExtractorName: CalleeDataExtractor) => ICalleeDataExtractor;
+export declare type TCalleeDataExtractorFactory = (calleeDataExtractorName: CalleeDataExtractor) => ICalleeDataExtractor;