javascript-obfuscator 2.18.1 → 3.0.1

package/typings/src/interfaces/options/IOptionsNormalizer.d.ts

@@ -0,0 +1,4 @@
+import { IOptions } from './IOptions';
+export interface IOptionsNormalizer {
+    normalize(options: IOptions): IOptions;
+}

package/typings/src/interfaces/source-code/IObfuscationResult.d.ts

@@ -0,0 +1,9 @@
+import { TIdentifierNamesCache } from '../../types/TIdentifierNamesCache';
+import { IInitializable } from '../IInitializable';
+import { IOptions } from '../options/IOptions';
+export interface IObfuscationResult extends IInitializable<[string, string]> {
+    getIdentifierNamesCache(): TIdentifierNamesCache;
+    getObfuscatedCode(): string;
+    getOptions(): IOptions;
+    getSourceMap(): string;
+}

package/typings/src/interfaces/source-code/ISourceCode.d.ts

@@ -0,0 +1,4 @@
+export interface ISourceCode {
+    getSourceCode(): string;
+    getSourceMap(): string;
+}

package/typings/src/interfaces/source-code/ISourceMap.d.ts

@@ -0,0 +1,5 @@
+export interface ISourceMap {
+    mappings: string;
+    sources: string[];
+    sourcesContent: string[];
+}

package/typings/src/interfaces/storages/IArrayStorage.d.ts

@@ -0,0 +1,13 @@
+import { IInitializable } from '../IInitializable';
+export interface IArrayStorage<V> extends IInitializable {
+    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;
+    toString(): string;
+}

package/typings/src/interfaces/storages/IMapStorage.d.ts

@@ -0,0 +1,15 @@
+import { TDictionary } from '../../types/TDictionary';
+import { IInitializable } from '../IInitializable';
+export interface IMapStorage<K, V> extends IInitializable {
+    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;
+    toString(): string;
+}

package/{src/interfaces/storages/identifier-names-cache/IGlobalIdentifierNamesCacheStorage.ts → typings/src/interfaces/storages/identifier-names-cache/IGlobalIdentifierNamesCacheStorage.d.ts}

@@ -1,4 +1,3 @@
 import { IMapStorage } from '../IMapStorage';
-
-// eslint-disable-next-line
-export interface IGlobalIdentifierNamesCacheStorage extends IMapStorage <string, string> {}
+export interface IGlobalIdentifierNamesCacheStorage extends IMapStorage<string, string> {
+}

package/{src/interfaces/storages/identifier-names-cache/IPropertyIdentifierNamesCacheStorage.ts → typings/src/interfaces/storages/identifier-names-cache/IPropertyIdentifierNamesCacheStorage.d.ts}

@@ -1,4 +1,3 @@
 import { IMapStorage } from '../IMapStorage';
-
-// eslint-disable-next-line
-export interface IPropertyIdentifierNamesCacheStorage extends IMapStorage <string, string> {}
+export interface IPropertyIdentifierNamesCacheStorage extends IMapStorage<string, string> {
+}

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

@@ -0,0 +1,7 @@
+import * as ESTree from 'estree';
+import { IMapStorage } from '../IMapStorage';
+import { IStringArrayStorageItemData } from './IStringArrayStorageItem';
+export interface ILiteralNodesCacheStorage extends IMapStorage<string, ESTree.Node> {
+    buildKey(literalValue: string, stringArrayStorageItemData: IStringArrayStorageItemData | undefined): string;
+    shouldUseCachedValue(key: string, stringArrayStorageItemData: IStringArrayStorageItemData | undefined): boolean;
+}

package/{src/interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrappersDataStorage.ts → typings/src/interfaces/storages/string-array-transformers/IStringArrayScopeCallsWrappersDataStorage.d.ts}

@@ -1,10 +1,5 @@
 import { TNodeWithLexicalScopeStatements } from '../../../types/node/TNodeWithLexicalScopeStatements';
 import { TStringArrayScopeCallsWrappersDataByEncoding } from '../../../types/node-transformers/string-array-transformers/TStringArrayScopeCallsWrappersDataByEncoding';
-
 import { IMapStorage } from '../IMapStorage';
-
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface IStringArrayScopeCallsWrappersDataStorage extends IMapStorage<
-    TNodeWithLexicalScopeStatements,
-    TStringArrayScopeCallsWrappersDataByEncoding
-> {}
+export interface IStringArrayScopeCallsWrappersDataStorage extends IMapStorage<TNodeWithLexicalScopeStatements, TStringArrayScopeCallsWrappersDataByEncoding> {
+}

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

@@ -0,0 +1,11 @@
+import { TStringArrayEncoding } from '../../../types/options/TStringArrayEncoding';
+import { IMapStorage } from '../IMapStorage';
+import { IStringArrayStorageItemData } from './IStringArrayStorageItem';
+export interface IStringArrayStorage extends IMapStorage<string, IStringArrayStorageItemData> {
+    getIndexShiftAmount(): number;
+    getRotationAmount(): number;
+    getStorageName(): string;
+    getStorageCallsWrapperName(stringArrayEncoding: TStringArrayEncoding | null): string;
+    rotateStorage(): void;
+    shuffleStorage(): void;
+}

package/{src/interfaces/storages/string-array-transformers/IStringArrayStorageItem.ts → typings/src/interfaces/storages/string-array-transformers/IStringArrayStorageItem.d.ts}

@@ -1,5 +1,4 @@
 import { IEncodedValue } from '../../IEncodedValue';
-
 export interface IStringArrayStorageItemData extends IEncodedValue {
     index: number;
     value: string;

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

@@ -0,0 +1,8 @@
+import { TNodeWithLexicalScopeStatements } from '../../../types/node/TNodeWithLexicalScopeStatements';
+import { IArrayStorage } from '../IArrayStorage';
+export interface IVisitedLexicalScopeNodesStackStorage extends IArrayStorage<TNodeWithLexicalScopeStatements> {
+    getLastElement(): TNodeWithLexicalScopeStatements | undefined;
+    getPenultimateElement(): TNodeWithLexicalScopeStatements | undefined;
+    pop(): TNodeWithLexicalScopeStatements | undefined;
+    push(lexicalScopeBodyNode: TNodeWithLexicalScopeStatements): void;
+}

package/typings/src/interfaces/utils/IArrayUtils.d.ts

@@ -0,0 +1,9 @@
+export interface IArrayUtils {
+    createWithRange(length: number): number[];
+    fillWithRange<TValue>(length: number, valueFunction: (index: number) => TValue): TValue[];
+    findMostOccurringElement<T extends string | number>(array: T[]): T | null;
+    getLastElement<T>(array: T[]): T | undefined;
+    getLastElementByIndex<T>(array: T[], index: number): T | undefined;
+    rotate<T>(array: T[], times: number): T[];
+    shuffle<T>(array: T[]): T[];
+}

package/typings/src/interfaces/utils/ICryptUtils.d.ts

@@ -0,0 +1,5 @@
+export interface ICryptUtils {
+    btoa(string: string): string;
+    hideString(str: string, length: number): [string, string];
+    rc4(string: string, key: string): string;
+}

package/typings/src/interfaces/utils/ICryptUtilsStringArray.d.ts

@@ -0,0 +1,3 @@
+import { ICryptUtils } from './ICryptUtils';
+export interface ICryptUtilsStringArray extends ICryptUtils {
+}

package/typings/src/interfaces/utils/IEscapeSequenceEncoder.d.ts

@@ -0,0 +1,3 @@
+export interface IEscapeSequenceEncoder {
+    encode(string: string, encodeAllSymbols: boolean): string;
+}

package/typings/src/interfaces/utils/ILevelledTopologicalSorter.d.ts

@@ -0,0 +1,5 @@
+export interface ILevelledTopologicalSorter<TValue extends string = string> {
+    add(precedent: TValue, consequent?: TValue | null): this;
+    sort(): TValue[];
+    sortByGroups(): TValue[][];
+}

package/typings/src/interfaces/utils/IRandomGenerator.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="chance" />
+export interface IRandomGenerator {
+    getMathRandom(): number;
+    getRandomGenerator(): Chance.Chance;
+    getRandomInteger(min: number, max: number): number;
+    getRandomIntegerExcluding(min: number, max: number, valuesToExclude: number[]): number;
+    getRandomString(length: number, pool?: string): string;
+    getInputSeed(): string;
+    getRawSeed(): string;
+}

package/typings/src/interfaces/utils/ITransformerNamesGroupsBuilder.d.ts

@@ -0,0 +1,4 @@
+import { TDictionary } from '../../types/TDictionary';
+export interface ITransformerNamesGroupsBuilder<TTransformerName extends string, TTransformer> {
+    build(normalizedTransformers: TDictionary<TTransformer>): TTransformerName[][];
+}

package/typings/src/logger/Logger.d.ts

@@ -0,0 +1,16 @@
+import { Chalk } from 'chalk';
+import { ILogger } from '../interfaces/logger/ILogger';
+import { IOptions } from '../interfaces/options/IOptions';
+import { LoggingMessage } from '../enums/logger/LoggingMessage';
+import { LoggingPrefix } from '../enums/logger/LoggingPrefix';
+export declare class Logger implements ILogger {
+    static readonly colorInfo: Chalk;
+    static readonly colorSuccess: Chalk;
+    static readonly colorWarn: Chalk;
+    private readonly options;
+    constructor(options: IOptions);
+    static log(loggingLevelColor: Chalk, loggingPrefix: LoggingPrefix, loggingMessage: string, value?: string | number): void;
+    info(loggingMessage: LoggingMessage, value?: string | number): void;
+    success(loggingMessage: LoggingMessage, value?: string | number): void;
+    warn(loggingMessage: LoggingMessage, value?: string | number): void;
+}

package/typings/src/node/NodeAppender.d.ts

@@ -0,0 +1,17 @@
+import * as ESTree from 'estree';
+import { TNodeWithStatements } from '../types/node/TNodeWithStatements';
+import { TStatement } from '../types/node/TStatement';
+import { ICallsGraphData } from '../interfaces/analyzers/calls-graph-analyzer/ICallsGraphData';
+export declare class NodeAppender {
+    static append(nodeWithStatements: TNodeWithStatements, statements: TStatement[]): void;
+    static appendToOptimalBlockScope(callsGraphData: ICallsGraphData[], nodeWithStatements: TNodeWithStatements, bodyStatements: TStatement[], index?: number): void;
+    static getOptimalBlockScope(callsGraphData: ICallsGraphData[], index: number, deep?: number): ESTree.BlockStatement;
+    static getScopeStatements(nodeWithStatements: TNodeWithStatements): TStatement[];
+    static insertBefore(nodeWithStatements: TNodeWithStatements, statements: TStatement[], target: ESTree.Statement): void;
+    static insertAfter(nodeWithStatements: TNodeWithStatements, statements: TStatement[], target: ESTree.Statement): void;
+    static insertAtIndex(nodeWithStatements: TNodeWithStatements, statements: TStatement[], index: number): void;
+    static prepend(nodeWithStatements: TNodeWithStatements, statements: TStatement[]): void;
+    static remove(nodeWithStatements: TNodeWithStatements, statement: ESTree.Statement): void;
+    private static parentizeScopeStatementsBeforeAppend;
+    private static setScopeStatements;
+}

package/typings/src/node/NodeFactory.d.ts

@@ -0,0 +1,43 @@
+import * as ESTree from 'estree';
+import { TStatement } from '../types/node/TStatement';
+export declare class NodeFactory {
+    static programNode(body?: TStatement[]): ESTree.Program;
+    static arrayExpressionNode(elements?: (ESTree.Expression | ESTree.SpreadElement)[]): ESTree.ArrayExpression;
+    static assignmentExpressionNode(operator: ESTree.AssignmentOperator, left: ESTree.Pattern | ESTree.MemberExpression, right: ESTree.Expression): ESTree.AssignmentExpression;
+    static binaryExpressionNode(operator: ESTree.BinaryOperator, left: ESTree.Expression, right: ESTree.Expression): ESTree.BinaryExpression;
+    static blockStatementNode(body?: ESTree.Statement[]): ESTree.BlockStatement;
+    static breakStatement(label?: ESTree.Identifier): ESTree.BreakStatement;
+    static callExpressionNode(callee: ESTree.Expression, args?: (ESTree.Expression | ESTree.SpreadElement)[], optional?: boolean): ESTree.CallExpression;
+    static conditionalExpressionNode(test: ESTree.Expression, consequent: ESTree.Expression, alternate: ESTree.Expression): ESTree.ConditionalExpression;
+    static continueStatement(label?: ESTree.Identifier): ESTree.ContinueStatement;
+    static directiveNode(expression: ESTree.Literal, directive: string): ESTree.Directive;
+    static doWhileStatementNode(body: ESTree.Statement, test: ESTree.Expression): ESTree.DoWhileStatement;
+    static exportAllDeclarationNode(source: ESTree.Literal, exported: ESTree.Identifier | null): ESTree.ExportAllDeclaration;
+    static exportNamedDeclarationNode(specifiers: ESTree.ExportSpecifier[], source: ESTree.Literal): ESTree.ExportNamedDeclaration;
+    static expressionStatementNode(expression: ESTree.Expression): ESTree.ExpressionStatement;
+    static forStatementNode(init: ESTree.VariableDeclaration | ESTree.Expression | null, test: ESTree.Expression | null, update: ESTree.Expression | null, body: ESTree.Statement): ESTree.ForStatement;
+    static forInStatementNode(left: ESTree.VariableDeclaration | ESTree.Pattern, right: ESTree.Expression, body: ESTree.Statement): ESTree.ForInStatement;
+    static forOfStatementNode(await: boolean, left: ESTree.VariableDeclaration | ESTree.Pattern, right: ESTree.Expression, body: ESTree.Statement): ESTree.ForOfStatement;
+    static functionDeclarationNode(functionName: string, params: ESTree.Identifier[], body: ESTree.BlockStatement): ESTree.FunctionDeclaration;
+    static functionExpressionNode(params: ESTree.Pattern[], body: ESTree.BlockStatement): ESTree.FunctionExpression;
+    static ifStatementNode(test: ESTree.Expression, consequent: ESTree.Statement, alternate?: ESTree.Statement | null): ESTree.IfStatement;
+    static identifierNode(name: string): ESTree.Identifier;
+    static importDeclarationNode(specifiers: (ESTree.ImportSpecifier | ESTree.ImportDefaultSpecifier | ESTree.ImportNamespaceSpecifier)[], source: ESTree.Literal): ESTree.ImportDeclaration;
+    static labeledStatementNode(label: ESTree.Identifier, body: ESTree.Statement): ESTree.LabeledStatement;
+    static literalNode(value: boolean | number | string, raw?: string): ESTree.Literal;
+    static logicalExpressionNode(operator: ESTree.LogicalOperator, left: ESTree.Expression, right: ESTree.Expression): ESTree.LogicalExpression;
+    static memberExpressionNode(object: ESTree.Expression | ESTree.Super, property: ESTree.Expression, computed?: boolean, optional?: boolean): ESTree.MemberExpression;
+    static objectExpressionNode(properties: (ESTree.Property | ESTree.SpreadElement)[]): ESTree.ObjectExpression;
+    static propertyNode(key: ESTree.Expression, value: ESTree.Expression | ESTree.Pattern, computed?: boolean): ESTree.Property;
+    static restElementNode(argument: ESTree.Pattern): ESTree.RestElement;
+    static returnStatementNode(argument: ESTree.Expression): ESTree.ReturnStatement;
+    static sequenceExpressionNode(expressions: ESTree.Expression[]): ESTree.SequenceExpression;
+    static spreadElementNode(argument: ESTree.Expression): ESTree.SpreadElement;
+    static switchStatementNode(discriminant: ESTree.Expression, cases: ESTree.SwitchCase[]): ESTree.SwitchStatement;
+    static switchCaseNode(test: ESTree.Expression, consequent: ESTree.Statement[]): ESTree.SwitchCase;
+    static unaryExpressionNode(operator: ESTree.UnaryOperator, argument: ESTree.Expression, prefix?: true): ESTree.UnaryExpression;
+    static updateExpressionNode(operator: ESTree.UpdateOperator, argumentExpr: ESTree.Expression): ESTree.UpdateExpression;
+    static variableDeclarationNode(declarations?: ESTree.VariableDeclarator[], kind?: 'var' | 'let' | 'const'): ESTree.VariableDeclaration;
+    static variableDeclaratorNode(id: ESTree.Identifier, init: ESTree.Expression | null): ESTree.VariableDeclarator;
+    static whileStatementNode(test: ESTree.Expression, body: ESTree.Statement): ESTree.WhileStatement;
+}

package/typings/src/node/NodeGuards.d.ts

@@ -0,0 +1,79 @@
+import * as ESTree from 'estree';
+import { TNodeWithLexicalScope } from '../types/node/TNodeWithLexicalScope';
+import { TNodeWithLexicalScopeStatements } from '../types/node/TNodeWithLexicalScopeStatements';
+import { TNodeWithSingleStatementBody } from '../types/node/TNodeWithSingleStatementBody';
+import { TNodeWithStatements } from '../types/node/TNodeWithStatements';
+export declare class NodeGuards {
+    private static readonly nodesWithLexicalStatements;
+    static isArrayPatternNode(node: ESTree.Node): node is ESTree.ArrayPattern;
+    static isArrowFunctionExpressionNode(node: ESTree.Node): node is ESTree.ArrowFunctionExpression;
+    static isAssignmentExpressionNode(node: ESTree.Node): node is ESTree.AssignmentExpression;
+    static isAssignmentPatternNode(node: ESTree.Node): node is ESTree.AssignmentPattern;
+    static isAwaitExpressionNode(node: ESTree.Node): node is ESTree.AwaitExpression;
+    static isBigIntLiteralNode(node: ESTree.Node): node is ESTree.BigIntLiteral;
+    static isBlockStatementNode(node: ESTree.Node): node is ESTree.BlockStatement;
+    static isBreakStatementNode(node: ESTree.Node): node is ESTree.BreakStatement;
+    static isCallExpressionNode(node: ESTree.Node): node is ESTree.CallExpression;
+    static isClassBodyNode(node: ESTree.Node): node is ESTree.ClassBody;
+    static isClassDeclarationNode(node: ESTree.Node): node is ESTree.ClassDeclaration & {
+        id: ESTree.Identifier;
+    };
+    static isConditionalExpressionNode(node: ESTree.Node): node is ESTree.ConditionalExpression;
+    static isContinueStatementNode(node: ESTree.Node): node is ESTree.ContinueStatement;
+    static isDirectiveNode(node: ESTree.Node): node is ESTree.Directive;
+    static isDoWhileStatementNode(node: ESTree.Node): node is ESTree.DoWhileStatement;
+    static isExportAllDeclarationNode(node: ESTree.Node): node is ESTree.ExportAllDeclaration;
+    static isExportNamedDeclarationNode(node: ESTree.Node): node is ESTree.ExportNamedDeclaration;
+    static isExportSpecifierNode(node: ESTree.Node): node is ESTree.ExportSpecifier;
+    static isExpressionStatementNode(node: ESTree.Node): node is ESTree.ExpressionStatement;
+    static isForStatementNode(node: ESTree.Node): node is ESTree.ForStatement;
+    static isForInStatementNode(node: ESTree.Node): node is ESTree.ForInStatement;
+    static isForOfStatementNode(node: ESTree.Node): node is ESTree.ForOfStatement;
+    static isFunctionNode(node: ESTree.Node): node is ESTree.Function;
+    static isFunctionDeclarationNode(node: ESTree.Node): node is ESTree.FunctionDeclaration & {
+        id: ESTree.Identifier;
+    };
+    static isFunctionExpressionNode(node: ESTree.Node): node is ESTree.FunctionExpression;
+    static isIdentifierNode(node: ESTree.Node): node is ESTree.Identifier;
+    static isIfStatementNode(node: ESTree.Node): node is ESTree.IfStatement;
+    static isIfStatementNodeWithSingleStatementBody(node: ESTree.Node): node is ESTree.IfStatement;
+    static isImportDeclarationNode(node: ESTree.Node): node is ESTree.ImportDeclaration;
+    static isImportExpressionNode(node: ESTree.Node): node is ESTree.ImportExpression;
+    static isImportSpecifierNode(node: ESTree.Node): node is ESTree.ImportSpecifier;
+    static isLabelIdentifierNode(node: ESTree.Node, parentNode: ESTree.Node): node is ESTree.Identifier;
+    static isLabeledStatementNode(node: ESTree.Node): node is ESTree.LabeledStatement;
+    static isLiteralNode(node: ESTree.Node): node is ESTree.Literal;
+    static isLogicalExpressionNode(node: ESTree.Node): node is ESTree.LogicalExpression;
+    static isMemberExpressionNode(node: ESTree.Node): node is ESTree.MemberExpression;
+    static isMethodDefinitionNode(node: ESTree.Node): node is ESTree.MethodDefinition;
+    static isNewExpressionNode(node: ESTree.Node): node is ESTree.NewExpression;
+    static isNode(object: Object & {
+        type?: string;
+    }): object is ESTree.Node;
+    static isNodeWithLexicalScope(node: ESTree.Node): node is TNodeWithLexicalScope;
+    static isNodeWithBlockLexicalScope(node: ESTree.Node): node is TNodeWithLexicalScope;
+    static isNodeWithSingleStatementBody(node: ESTree.Node): node is TNodeWithSingleStatementBody;
+    static isNodeWithLexicalScopeStatements(node: ESTree.Node, parentNode: ESTree.Node): node is TNodeWithLexicalScopeStatements;
+    static isNodeWithStatements(node: ESTree.Node): node is TNodeWithStatements;
+    static isNodeWithComments(node: ESTree.Node): node is ESTree.Node;
+    static isObjectPatternNode(node: ESTree.Node): node is ESTree.ObjectPattern;
+    static isObjectExpressionNode(node: ESTree.Node): node is ESTree.ObjectExpression;
+    static isProgramNode(node: ESTree.Node): node is ESTree.Program;
+    static isPropertyNode(node: ESTree.Node): node is ESTree.Property;
+    static isPropertyDefinitionNode(node: ESTree.Node): node is ESTree.PropertyDefinition;
+    static isRestElementNode(node: ESTree.Node): node is ESTree.RestElement;
+    static isReturnStatementNode(node: ESTree.Node): node is ESTree.ReturnStatement;
+    static isSequenceExpressionNode(node: ESTree.Node): node is ESTree.SequenceExpression;
+    static isSpreadElementNode(node: ESTree.Node): node is ESTree.SpreadElement;
+    static isSuperNode(node: ESTree.Node): node is ESTree.Super;
+    static isSwitchCaseNode(node: ESTree.Node): node is ESTree.SwitchCase;
+    static isTaggedTemplateExpressionNode(node: ESTree.Node): node is ESTree.TaggedTemplateExpression;
+    static isTemplateLiteralNode(node: ESTree.Node): node is ESTree.TemplateLiteral;
+    static isThisExpressionNode(node: ESTree.Node): node is ESTree.ThisExpression;
+    static isUnaryExpressionNode(node: ESTree.Node): node is ESTree.UnaryExpression;
+    static isVariableDeclarationNode(node: ESTree.Node): node is ESTree.VariableDeclaration;
+    static isVariableDeclaratorNode(node: ESTree.Node): node is ESTree.VariableDeclarator;
+    static isWithStatementNode(node: ESTree.Node): node is ESTree.WithStatement;
+    static isWhileStatementNode(node: ESTree.Node): node is ESTree.WhileStatement;
+    static isYieldExpressionNode(node: ESTree.Node): node is ESTree.YieldExpression;
+}

package/typings/src/node/NodeLexicalScopeUtils.d.ts

@@ -0,0 +1,7 @@
+import * as ESTree from 'estree';
+import { TNodeWithLexicalScope } from '../types/node/TNodeWithLexicalScope';
+export declare class NodeLexicalScopeUtils {
+    static getLexicalScope(node: ESTree.Node): TNodeWithLexicalScope | undefined;
+    static getLexicalScopes(node: ESTree.Node): TNodeWithLexicalScope[];
+    private static getLexicalScopesRecursive;
+}

package/typings/src/node/NodeLiteralUtils.d.ts

@@ -0,0 +1,6 @@
+import * as ESTree from 'estree';
+import { TStringLiteralNode } from '../types/node/TStringLiteralNode';
+export declare class NodeLiteralUtils {
+    static isStringLiteralNode(literalNode: ESTree.Literal): literalNode is TStringLiteralNode;
+    static isProhibitedLiteralNode(literalNode: ESTree.Literal, parentNode: ESTree.Node): boolean;
+}

package/typings/src/node/NodeMetadata.d.ts

@@ -0,0 +1,8 @@
+import * as ESTree from 'estree';
+export declare class NodeMetadata {
+    static set<T extends ESTree.Node = ESTree.Node>(node: T, metadata: Partial<T['metadata']>): void;
+    static get<T extends ESTree.BaseNodeMetadata, TMetadataKey extends keyof T>(node: ESTree.Node, metadataKey: TMetadataKey): T[TMetadataKey] | undefined;
+    static isForceTransformNode(node: ESTree.Node): boolean;
+    static isIgnoredNode(node: ESTree.Node): boolean;
+    static isStringArrayCallLiteralNode(literalNode: ESTree.Literal): boolean;
+}

package/typings/src/node/NodeStatementUtils.d.ts

@@ -0,0 +1,13 @@
+import * as ESTree from 'estree';
+import { TNodeWithStatements } from '../types/node/TNodeWithStatements';
+import { TStatement } from '../types/node/TStatement';
+export declare class NodeStatementUtils {
+    static getParentNodeWithStatements(node: ESTree.Node): TNodeWithStatements;
+    static getParentNodesWithStatements(node: ESTree.Node): TNodeWithStatements[];
+    static getNextSiblingStatement(statement: ESTree.Statement): TStatement | null;
+    static getPreviousSiblingStatement(statement: ESTree.Statement): TStatement | null;
+    static getRootStatementOfNode(node: ESTree.Node): ESTree.Statement;
+    static getScopeOfNode(node: ESTree.Node): TNodeWithStatements;
+    private static getParentNodesWithStatementsRecursive;
+    private static getSiblingStatementByOffset;
+}

package/typings/src/node/NodeUtils.d.ts

@@ -0,0 +1,11 @@
+import * as ESTree from 'estree';
+export declare class NodeUtils {
+    static addXVerbatimPropertyTo(literalNode: ESTree.Literal): ESTree.Literal;
+    static clone<T extends ESTree.Node = ESTree.Node>(astTree: T): T;
+    static convertCodeToStructure(code: string): ESTree.Statement[];
+    static convertStructureToCode(structure: ESTree.Node[]): string;
+    static getUnaryExpressionArgumentNode(unaryExpressionNode: ESTree.UnaryExpression): ESTree.Node;
+    static parentizeAst<T extends ESTree.Node = ESTree.Node>(astTree: T): T;
+    static parentizeNode<T extends ESTree.Node = ESTree.Node>(node: T, parentNode: ESTree.Node | null): T;
+    private static cloneRecursive;
+}

package/typings/src/node/NumericalExpressionDataToNodeConverter.d.ts

@@ -0,0 +1,10 @@
+import * as ESTree from 'estree';
+import { TNumericalExpressionDataToNodeConverterLiteralNodeGetter } from '../types/node/TNumericalExpressionDataToNodeConverterLiteralNodeGetter';
+import { TNumberNumericalExpressionData } from '../types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
+export declare class NumericalExpressionDataToNodeConverter {
+    static convertIntegerNumberData(numberNumericalExpressionData: TNumberNumericalExpressionData, literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter): ESTree.Expression;
+    static convertFloatNumberData(integerNumberNumericalExpressionData: TNumberNumericalExpressionData, decimalPart: number, literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter): ESTree.Expression;
+    private static convertNumericalExpressionDataToNode;
+    private static convertPartsToBinaryExpression;
+    private static convertPartOrNumberToLiteralNode;
+}

package/typings/src/node/ScopeIdentifiersTraverser.d.ts

@@ -0,0 +1,16 @@
+import * as ESTree from 'estree';
+import { TScopeIdentifiersTraverserCallback } from '../types/node/TScopeIdentifiersTraverserCallback';
+import { IScopeAnalyzer } from '../interfaces/analyzers/scope-analyzer/IScopeAnalyzer';
+import { IScopeIdentifiersTraverser } from '../interfaces/node/IScopeIdentifiersTraverser';
+import { IScopeIdentifiersTraverserCallbackData } from '../interfaces/node/IScopeIdentifiersTraverserCallbackData';
+import { IScopeThroughIdentifiersTraverserCallbackData } from '../interfaces/node/IScopeThroughIdentifiersTraverserCallbackData';
+export declare class ScopeIdentifiersTraverser implements IScopeIdentifiersTraverser {
+    private static readonly argumentsVariableName;
+    private static readonly globalScopeNames;
+    private readonly scopeAnalyzer;
+    constructor(scopeAnalyzer: IScopeAnalyzer);
+    traverseScopeIdentifiers(programNode: ESTree.Program, parentNode: ESTree.Node | null, callback: TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>): void;
+    traverseScopeThroughIdentifiers(programNode: ESTree.Program, parentNode: ESTree.Node | null, callback: TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>): void;
+    private traverseScopeIdentifiersRecursive;
+    private traverseScopeThroughIdentifiersRecursive;
+}

package/typings/src/node-transformers/AbstractNodeTransformer.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="estraverse" />
+import * as estraverse from '@javascript-obfuscator/estraverse';
+import * as ESTree from 'estree';
+import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
+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';
+export declare abstract class AbstractNodeTransformer implements INodeTransformer {
+    readonly runAfter: NodeTransformer[] | undefined;
+    protected readonly options: IOptions;
+    protected readonly randomGenerator: IRandomGenerator;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    abstract getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    abstract transformNode(node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node | estraverse.VisitorOption;
+}

package/{src/node-transformers/NodeTransformerNamesGroupsBuilder.ts → typings/src/node-transformers/NodeTransformerNamesGroupsBuilder.d.ts}

@@ -1,13 +1,5 @@
-import { injectable } from 'inversify';
-
 import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
-
 import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
-
 import { AbstractTransformerNamesGroupsBuilder } from '../utils/AbstractTransformerNamesGroupsBuilder';
-
-@injectable()
-export class NodeTransformerNamesGroupsBuilder extends AbstractTransformerNamesGroupsBuilder<
-    NodeTransformer,
-    INodeTransformer
-> {}
+export declare class NodeTransformerNamesGroupsBuilder extends AbstractTransformerNamesGroupsBuilder<NodeTransformer, INodeTransformer> {
+}

package/typings/src/node-transformers/NodeTransformersRunner.d.ts

@@ -0,0 +1,15 @@
+import * as ESTree from 'estree';
+import { TNodeTransformerFactory } from '../types/container/node-transformers/TNodeTransformerFactory';
+import { INodeTransformer } from '../interfaces/node-transformers/INodeTransformer';
+import { INodeTransformersRunner } from '../interfaces/node-transformers/INodeTransformersRunner';
+import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
+import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
+import { NodeTransformationStage } from '../enums/node-transformers/NodeTransformationStage';
+export declare class NodeTransformersRunner implements INodeTransformersRunner {
+    private readonly nodeTransformerFactory;
+    private readonly nodeTransformerNamesGroupsBuilder;
+    constructor(nodeTransformerFactory: TNodeTransformerFactory, nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<NodeTransformer, INodeTransformer>);
+    transform<T extends ESTree.Node = ESTree.Program>(astTree: T, nodeTransformerNames: NodeTransformer[], nodeTransformationStage: NodeTransformationStage): T;
+    private buildNormalizedNodeTransformers;
+    private mergeVisitorsForDirection;
+}

package/typings/src/node-transformers/control-flow-transformers/BlockStatementControlFlowTransformer.d.ts

@@ -0,0 +1,17 @@
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+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 BlockStatementControlFlowTransformer extends AbstractNodeTransformer {
+    private readonly arrayUtils;
+    private readonly controlFlowCustomNodeFactory;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
+    private static isProhibitedStatementNode;
+    private static canTransformBlockStatementNode;
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    transformNode(blockStatementNode: ESTree.BlockStatement, parentNode: ESTree.Node): ESTree.Node;
+}

package/typings/src/node-transformers/control-flow-transformers/FunctionControlFlowTransformer.d.ts

@@ -0,0 +1,28 @@
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { TControlFlowReplacerFactory } from '../../types/container/node-transformers/TControlFlowReplacerFactory';
+import { TControlFlowStorageFactory } from '../../types/container/node-transformers/TControlFlowStorageFactory';
+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 FunctionControlFlowTransformer extends AbstractNodeTransformer {
+    private static readonly controlFlowReplacersMap;
+    private static readonly hostNodeSearchMinDepth;
+    private static readonly hostNodeSearchMaxDepth;
+    private readonly controlFlowData;
+    private readonly visitedFunctionNodes;
+    private readonly hostNodesWithControlFlowNode;
+    private readonly controlFlowReplacerFactory;
+    private readonly controlFlowStorageFactory;
+    private readonly controlFlowCustomNodeFactory;
+    constructor(controlFlowStorageFactory: TControlFlowStorageFactory, controlFlowReplacerFactory: TControlFlowReplacerFactory, controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    transformNode(functionNode: ESTree.Function, parentNode: ESTree.Node): ESTree.Function;
+    private getControlFlowStorage;
+    private getControlFlowStorageNode;
+    private getHostNode;
+    private isVisitedFunctionNode;
+    private transformFunctionBody;
+}

package/typings/src/node-transformers/control-flow-transformers/control-flow-replacers/AbstractControlFlowReplacer.d.ts

@@ -0,0 +1,17 @@
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { IControlFlowReplacer } from '../../../interfaces/node-transformers/control-flow-transformers/IControlFlowReplacer';
+import { ICustomNode } from '../../../interfaces/custom-nodes/ICustomNode';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+export declare abstract class AbstractControlFlowReplacer implements IControlFlowReplacer {
+    protected readonly controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory;
+    protected readonly options: IOptions;
+    protected readonly randomGenerator: IRandomGenerator;
+    protected readonly replacerDataByControlFlowStorageId: Map<string, Map<string, string[]>>;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    protected static getStorageKeysByIdForCurrentStorage(identifierDataByControlFlowStorageId: Map<string, Map<string, string[]>>, controlFlowStorageId: string): Map<string, string[]>;
+    protected insertCustomNodeToControlFlowStorage(customNode: ICustomNode, controlFlowStorage: TControlFlowStorage, replacerId: string, usingExistingIdentifierChance: number): string;
+    abstract replace(node: ESTree.Node, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+}

package/typings/src/node-transformers/control-flow-transformers/control-flow-replacers/BinaryExpressionControlFlowReplacer.d.ts

@@ -0,0 +1,11 @@
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { ExpressionWithOperatorControlFlowReplacer } from './ExpressionWithOperatorControlFlowReplacer';
+export declare class BinaryExpressionControlFlowReplacer extends ExpressionWithOperatorControlFlowReplacer {
+    private static readonly usingExistingIdentifierChance;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    replace(binaryExpressionNode: ESTree.BinaryExpression, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+}

package/typings/src/node-transformers/control-flow-transformers/control-flow-replacers/CallExpressionControlFlowReplacer.d.ts

@@ -0,0 +1,12 @@
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
+export declare class CallExpressionControlFlowReplacer extends AbstractControlFlowReplacer {
+    private static readonly usingExistingIdentifierChance;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    replace(callExpressionNode: ESTree.CallExpression, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+    protected getControlFlowStorageCallNode(controlFlowStorageId: string, storageKey: string, callee: ESTree.Expression, expressionArguments: (ESTree.Expression | ESTree.SpreadElement)[]): ESTree.Node;
+}

package/typings/src/node-transformers/control-flow-transformers/control-flow-replacers/ExpressionWithOperatorControlFlowReplacer.d.ts

@@ -0,0 +1,9 @@
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractControlFlowReplacer } from './AbstractControlFlowReplacer';
+export declare abstract class ExpressionWithOperatorControlFlowReplacer extends AbstractControlFlowReplacer {
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    protected getControlFlowStorageCallNode(controlFlowStorageId: string, storageKey: string, leftExpression: ESTree.Expression, rightExpression: ESTree.Expression): ESTree.Node;
+}

package/typings/src/node-transformers/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer.d.ts

@@ -0,0 +1,12 @@
+import * as ESTree from 'estree';
+import { TControlFlowCustomNodeFactory } from '../../../types/container/custom-nodes/TControlFlowCustomNodeFactory';
+import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { ExpressionWithOperatorControlFlowReplacer } from './ExpressionWithOperatorControlFlowReplacer';
+export declare class LogicalExpressionControlFlowReplacer extends ExpressionWithOperatorControlFlowReplacer {
+    private static readonly usingExistingIdentifierChance;
+    constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    replace(logicalExpressionNode: ESTree.LogicalExpression, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+    private checkForProhibitedExpressions;
+}