javascript-obfuscator 2.18.0 → 3.0.0

package/typings/src/custom-nodes/control-flow-flattening-nodes/LogicalExpressionFunctionNode.d.ts

@@ -0,0 +1,13 @@
+import type { LogicalOperator } from 'estree';
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../types/node/TStatement';
+import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { AbstractCustomNode } from '../AbstractCustomNode';
+export declare class LogicalExpressionFunctionNode extends AbstractCustomNode {
+    private operator;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(operator: LogicalOperator): void;
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/control-flow-flattening-nodes/StringLiteralNode.d.ts

@@ -0,0 +1,12 @@
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../types/node/TStatement';
+import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { AbstractCustomNode } from '../AbstractCustomNode';
+export declare class StringLiteralNode extends AbstractCustomNode {
+    private literalValue;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(literalValue: string): void;
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/CallExpressionControlFlowStorageCallNode.d.ts

@@ -0,0 +1,16 @@
+import type * as ESTree from 'estree';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../../types/node/TStatement';
+import { ICustomCodeHelperFormatter } from '../../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractCustomNode } from '../../AbstractCustomNode';
+export declare class CallExpressionControlFlowStorageCallNode extends AbstractCustomNode {
+    private callee;
+    private controlFlowStorageKey;
+    private controlFlowStorageName;
+    private expressionArguments;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(controlFlowStorageName: string, controlFlowStorageKey: string, callee: ESTree.Expression, expressionArguments: (ESTree.Expression | ESTree.SpreadElement)[]): void;
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ControlFlowStorageNode.d.ts

@@ -0,0 +1,13 @@
+import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../../types/node/TStatement';
+import { ICustomCodeHelperFormatter } from '../../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractCustomNode } from '../../AbstractCustomNode';
+export declare class ControlFlowStorageNode extends AbstractCustomNode {
+    private controlFlowStorage;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(controlFlowStorage: TControlFlowStorage): void;
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/ExpressionWithOperatorControlFlowStorageCallNode.d.ts

@@ -0,0 +1,16 @@
+import type { Expression } from 'estree';
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../../types/node/TStatement';
+import { ICustomCodeHelperFormatter } from '../../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractCustomNode } from '../../AbstractCustomNode';
+export declare class ExpressionWithOperatorControlFlowStorageCallNode extends AbstractCustomNode {
+    private controlFlowStorageKey;
+    private controlFlowStorageName;
+    private leftValue;
+    private rightValue;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(controlFlowStorageName: string, controlFlowStorageKey: string, leftValue: Expression, rightValue: Expression): void;
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/control-flow-flattening-nodes/control-flow-storage-nodes/StringLiteralControlFlowStorageCallNode.d.ts

@@ -0,0 +1,13 @@
+import { TIdentifierNamesGeneratorFactory } from '../../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../../types/node/TStatement';
+import { ICustomCodeHelperFormatter } from '../../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractCustomNode } from '../../AbstractCustomNode';
+export declare class StringLiteralControlFlowStorageCallNode extends AbstractCustomNode {
+    private controlFlowStorageKey;
+    private controlFlowStorageName;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(controlFlowStorageName: string, controlFlowStorageKey: string): void;
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/dead-code-injection-nodes/BlockStatementDeadCodeInjectionNode.d.ts

@@ -0,0 +1,15 @@
+import type { BlockStatement } from 'estree';
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../types/node/TStatement';
+import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { AbstractCustomNode } from '../AbstractCustomNode';
+export declare class BlockStatementDeadCodeInjectionNode extends AbstractCustomNode {
+    private blockStatementNode;
+    private deadCodeInjectionRootAstHostNode;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(blockStatementNode: BlockStatement, deadCodeInjectionRootAstHostNode: BlockStatement): void;
+    getNode(): TStatement[];
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/object-expression-keys-transformer-nodes/ObjectExpressionVariableDeclarationHostNode.d.ts

@@ -0,0 +1,15 @@
+import * as ESTree from 'estree';
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
+import { TStatement } from '../../types/node/TStatement';
+import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { AbstractCustomNode } from '../AbstractCustomNode';
+export declare class ObjectExpressionVariableDeclarationHostNode extends AbstractCustomNode {
+    private lexicalScopeNode;
+    private properties;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(lexicalScopeNode: TNodeWithLexicalScope, properties: (ESTree.Property | ESTree.SpreadElement)[]): void;
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/string-array-nodes/AbstractStringArrayCallNode.d.ts

@@ -0,0 +1,19 @@
+import * as ESTree from 'estree';
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStringArrayIndexNodeFactory } from '../../types/container/custom-nodes/string-array-index-nodes/TStringArrayIndexNodeFactory';
+import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { AbstractCustomNode } from '../AbstractCustomNode';
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+export declare abstract class AbstractStringArrayCallNode extends AbstractCustomNode {
+    protected static readonly stringArrayRootCallsWrapperParametersCount: number;
+    private static readonly stringArrayIndexNodesMap;
+    protected readonly arrayUtils: IArrayUtils;
+    protected readonly stringArrayStorage: IStringArrayStorage;
+    private readonly stringArrayIndexNodeFactory;
+    protected constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, stringArrayIndexNodeFactory: TStringArrayIndexNodeFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, stringArrayStorage: IStringArrayStorage, arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
+    protected getStringArrayIndexNode(index: number): ESTree.Expression;
+    protected getRc4KeyLiteralNode(decodeKey: string): ESTree.Literal;
+}

package/typings/src/custom-nodes/string-array-nodes/StringArrayCallNode.d.ts

@@ -0,0 +1,21 @@
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../types/node/TStatement';
+import { TStringArrayIndexNodeFactory } from '../../types/container/custom-nodes/string-array-index-nodes/TStringArrayIndexNodeFactory';
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { AbstractStringArrayCallNode } from './AbstractStringArrayCallNode';
+import { IStringArrayScopeCallsWrapperData } from '../../interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperData';
+export declare class StringArrayCallNode extends AbstractStringArrayCallNode {
+    private decodeKey;
+    private index;
+    private indexShiftAmount;
+    private stringArrayCallsWrapperData;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, stringArrayIndexNodeFactory: TStringArrayIndexNodeFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, stringArrayStorage: IStringArrayStorage, arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(index: number, indexShiftAmount: number, stringArrayCallsWrapperData: IStringArrayScopeCallsWrapperData, decodeKey: string | null): void;
+    protected getNodeStructure(): TStatement[];
+    private getFakeStringArrayIndexNode;
+    private getFakeStringArrayIndex;
+}

package/typings/src/custom-nodes/string-array-nodes/StringArrayScopeCallsWrapperFunctionNode.d.ts

@@ -0,0 +1,20 @@
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../types/node/TStatement';
+import { TStringArrayIndexNodeFactory } from '../../types/container/custom-nodes/string-array-index-nodes/TStringArrayIndexNodeFactory';
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayScopeCallsWrapperData } from '../../interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperData';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { AbstractStringArrayCallNode } from './AbstractStringArrayCallNode';
+export declare class StringArrayScopeCallsWrapperFunctionNode extends AbstractStringArrayCallNode {
+    private upperStringArrayCallsWrapperData;
+    private stringArrayScopeCallsWrapperData;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, stringArrayIndexNodeFactory: TStringArrayIndexNodeFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, stringArrayStorage: IStringArrayStorage, arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(stringArrayScopeCallsWrapperData: IStringArrayScopeCallsWrapperData, upperStringArrayCallsWrapperData: IStringArrayScopeCallsWrapperData): void;
+    protected getNodeStructure(): TStatement[];
+    private getUpperStringArrayCallNode;
+    private getFakeParameterNode;
+    private getFakeUpperStringArrayIndexNode;
+}

package/typings/src/custom-nodes/string-array-nodes/StringArrayScopeCallsWrapperVariableNode.d.ts

@@ -0,0 +1,17 @@
+import { TIdentifierNamesGeneratorFactory } from '../../types/container/generators/TIdentifierNamesGeneratorFactory';
+import { TStatement } from '../../types/node/TStatement';
+import { TStringArrayIndexNodeFactory } from '../../types/container/custom-nodes/string-array-index-nodes/TStringArrayIndexNodeFactory';
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+import { ICustomCodeHelperFormatter } from '../../interfaces/custom-code-helpers/ICustomCodeHelperFormatter';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayScopeCallsWrapperData } from '../../interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperData';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { AbstractStringArrayCallNode } from './AbstractStringArrayCallNode';
+export declare class StringArrayScopeCallsWrapperVariableNode extends AbstractStringArrayCallNode {
+    private stringArrayCallsWrapperData;
+    private stringArrayScopeCallsWrapperData;
+    constructor(identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, stringArrayIndexNodeFactory: TStringArrayIndexNodeFactory, customCodeHelperFormatter: ICustomCodeHelperFormatter, stringArrayStorage: IStringArrayStorage, arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(stringArrayScopeCallsWrapperData: IStringArrayScopeCallsWrapperData, stringArrayCallsWrapperData: IStringArrayScopeCallsWrapperData): void;
+    protected getNodeStructure(): TStatement[];
+}

package/typings/src/custom-nodes/string-array-nodes/string-array-index-nodes/AbstractStringArrayIndexNode.d.ts

@@ -0,0 +1,10 @@
+import * as ESTree from 'estree';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { IStringArrayIndexNode } from '../../../interfaces/custom-nodes/string-array-nodes/IStringArrayIndexNode';
+export declare abstract class AbstractStringArrayIndexNode implements IStringArrayIndexNode {
+    protected readonly options: IOptions;
+    protected readonly randomGenerator: IRandomGenerator;
+    protected constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    abstract getNode(index: number): ESTree.Expression;
+}

package/typings/src/custom-nodes/string-array-nodes/string-array-index-nodes/StringArrayHexadecimalNumberIndexNode.d.ts

@@ -0,0 +1,8 @@
+import * as ESTree from 'estree';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractStringArrayIndexNode } from './AbstractStringArrayIndexNode';
+export declare class StringArrayHexadecimalNumberIndexNode extends AbstractStringArrayIndexNode {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    getNode(index: number): ESTree.Expression;
+}

package/typings/src/custom-nodes/string-array-nodes/string-array-index-nodes/StringArrayHexadecimalNumericStringIndexNode.d.ts

@@ -0,0 +1,8 @@
+import * as ESTree from 'estree';
+import { IOptions } from '../../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../../interfaces/utils/IRandomGenerator';
+import { AbstractStringArrayIndexNode } from './AbstractStringArrayIndexNode';
+export declare class StringArrayHexadecimalNumericStringIndexNode extends AbstractStringArrayIndexNode {
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    getNode(index: number): ESTree.Expression;
+}

package/typings/src/decorators/Initializable.d.ts

@@ -0,0 +1,2 @@
+import { IInitializable } from '../interfaces/IInitializable';
+export declare function initializable(): (target: IInitializable, propertyKey: string | symbol) => any;

package/typings/src/enums/ObfuscationTarget.d.ts

@@ -0,0 +1,5 @@
+export declare const ObfuscationTarget: Readonly<{
+    Browser: 'browser';
+    BrowserNoEval: 'browser-no-eval';
+    Node: 'node';
+}>;

package/typings/src/enums/StringSeparator.d.ts

@@ -0,0 +1,5 @@
+export declare enum StringSeparator {
+    Comma = ",",
+    Dot = ".",
+    VerticalLine = "|"
+}

package/typings/src/enums/analyzers/calls-graph-analyzer/CalleeDataExtractor.d.ts

@@ -0,0 +1,5 @@
+export declare enum CalleeDataExtractor {
+    FunctionDeclarationCalleeDataExtractor = "FunctionDeclarationCalleeDataExtractor",
+    FunctionExpressionCalleeDataExtractor = "FunctionExpressionCalleeDataExtractor",
+    ObjectExpressionCalleeDataExtractor = "ObjectExpressionCalleeDataExtractor"
+}

package/typings/src/enums/code-transformers/CodeTransformationStage.d.ts

@@ -0,0 +1,4 @@
+export declare enum CodeTransformationStage {
+    PreparingTransformers = "PreparingTransformers",
+    FinalizingTransformers = "FinalizingTransformers"
+}

package/typings/src/enums/code-transformers/CodeTransformer.d.ts

@@ -0,0 +1,3 @@
+export declare enum CodeTransformer {
+    HashbangOperatorTransformer = "HashbangOperatorTransformer"
+}

package/typings/src/enums/custom-code-helpers/CustomCodeHelper.d.ts

@@ -0,0 +1,14 @@
+export declare enum CustomCodeHelper {
+    CallsControllerFunction = "CallsControllerFunction",
+    ConsoleOutputDisable = "ConsoleOutputDisable",
+    DebugProtectionFunctionCall = "DebugProtectionFunctionCall",
+    DebugProtectionFunctionInterval = "DebugProtectionFunctionInterval",
+    DebugProtectionFunction = "DebugProtectionFunction",
+    DomainLock = "DomainLock",
+    SelfDefending = "SelfDefending",
+    StringArray = "StringArray",
+    StringArrayCallsWrapper = "StringArrayCallsWrapper",
+    StringArrayCallsWrapperBase64 = "StringArrayCallsWrapperBase64",
+    StringArrayCallsWrapperRc4 = "StringArrayCallsWrapperRc4",
+    StringArrayRotateFunction = "StringArrayRotateFunction"
+}

package/typings/src/enums/custom-code-helpers/CustomCodeHelperGroup.d.ts

@@ -0,0 +1,7 @@
+export declare enum CustomCodeHelperGroup {
+    ConsoleOutput = "ConsoleOutput",
+    DebugProtection = "DebugProtection",
+    DomainLock = "DomainLock",
+    SelfDefending = "SelfDefending",
+    StringArray = "StringArray"
+}

package/typings/src/enums/custom-nodes/ControlFlowCustomNode.d.ts

@@ -0,0 +1,11 @@
+export declare enum ControlFlowCustomNode {
+    BinaryExpressionFunctionNode = "BinaryExpressionFunctionNode",
+    BlockStatementControlFlowFlatteningNode = "BlockStatementControlFlowFlatteningNode",
+    CallExpressionControlFlowStorageCallNode = "CallExpressionControlFlowStorageCallNode",
+    CallExpressionFunctionNode = "CallExpressionFunctionNode",
+    ControlFlowStorageNode = "ControlFlowStorageNode",
+    ExpressionWithOperatorControlFlowStorageCallNode = "ExpressionWithOperatorControlFlowStorageCallNode",
+    LogicalExpressionFunctionNode = "LogicalExpressionFunctionNode",
+    StringLiteralControlFlowStorageCallNode = "StringLiteralControlFlowStorageCallNode",
+    StringLiteralNode = "StringLiteralNode"
+}

package/typings/src/enums/custom-nodes/DeadCodeInjectionCustomNode.d.ts

@@ -0,0 +1,3 @@
+export declare enum DeadCodeInjectionCustomNode {
+    BlockStatementDeadCodeInjectionNode = "BlockStatementDeadCodeInjectionNode"
+}

package/typings/src/enums/custom-nodes/ObjectExpressionKeysTransformerCustomNode.d.ts

@@ -0,0 +1,3 @@
+export declare enum ObjectExpressionKeysTransformerCustomNode {
+    ObjectExpressionVariableDeclarationHostNode = "ObjectExpressionVariableDeclarationHostNode"
+}

package/typings/src/enums/custom-nodes/StringArrayCustomNode.d.ts

@@ -0,0 +1,5 @@
+export declare enum StringArrayCustomNode {
+    StringArrayCallNode = "StringArrayCallNode",
+    StringArrayScopeCallsWrapperFunctionNode = "StringArrayScopeCallsWrapperFunctionNode",
+    StringArrayScopeCallsWrapperVariableNode = "StringArrayScopeCallsWrapperVariableNode"
+}

package/typings/src/enums/custom-nodes/string-array-index-nodes/StringArrayIndexNode.d.ts

@@ -0,0 +1,4 @@
+export declare enum StringArrayIndexNode {
+    StringArrayHexadecimalNumberIndexNode = "StringArrayHexadecimalNumberIndexNode",
+    StringArrayHexadecimalNumericStringIndexNode = "StringArrayHexadecimalNumericStringIndexNode"
+}

package/typings/src/enums/generators/identifier-names-generators/IdentifierNamesGenerator.d.ts

@@ -0,0 +1,6 @@
+export declare const IdentifierNamesGenerator: Readonly<{
+    DictionaryIdentifierNamesGenerator: 'dictionary';
+    HexadecimalIdentifierNamesGenerator: 'hexadecimal';
+    MangledIdentifierNamesGenerator: 'mangled';
+    MangledShuffledIdentifierNamesGenerator: 'mangled-shuffled';
+}>;

package/typings/src/enums/logger/LoggingMessage.d.ts

@@ -0,0 +1,9 @@
+export declare enum LoggingMessage {
+    EmptySourceCode = "Empty source code. Obfuscation canceled...",
+    ObfuscationCompleted = "Obfuscation completed. Total time: %s sec.",
+    ObfuscationStarted = "Obfuscation started...",
+    RandomGeneratorSeed = "Random generator seed: %s...",
+    CodeTransformationStage = "Code transformation stage: %s...",
+    NodeTransformationStage = "AST transformation stage: %s...",
+    Version = "Version: %s"
+}

package/typings/src/enums/logger/LoggingPrefix.d.ts

@@ -0,0 +1,4 @@
+export declare enum LoggingPrefix {
+    Base = "[javascript-obfuscator]",
+    CLI = "[javascript-obfuscator-cli]"
+}

package/typings/src/enums/node/NodeType.d.ts

@@ -0,0 +1,66 @@
+export declare enum NodeType {
+    ArrayExpression = "ArrayExpression",
+    ArrayPattern = "ArrayPattern",
+    ArrowFunctionExpression = "ArrowFunctionExpression",
+    AssignmentExpression = "AssignmentExpression",
+    AssignmentPattern = "AssignmentPattern",
+    AwaitExpression = "AwaitExpression",
+    BinaryExpression = "BinaryExpression",
+    BlockStatement = "BlockStatement",
+    BreakStatement = "BreakStatement",
+    CallExpression = "CallExpression",
+    CatchClause = "CatchClause",
+    ChainExpression = "ChainExpression",
+    ClassBody = "ClassBody",
+    ClassDeclaration = "ClassDeclaration",
+    ConditionalExpression = "ConditionalExpression",
+    ContinueStatement = "ContinueStatement",
+    DoWhileStatement = "DoWhileStatement",
+    ExportAllDeclaration = "ExportAllDeclaration",
+    ExportNamedDeclaration = "ExportNamedDeclaration",
+    ExportSpecifier = "ExportSpecifier",
+    ExpressionStatement = "ExpressionStatement",
+    ForStatement = "ForStatement",
+    ForInStatement = "ForInStatement",
+    ForOfStatement = "ForOfStatement",
+    FunctionDeclaration = "FunctionDeclaration",
+    FunctionExpression = "FunctionExpression",
+    Identifier = "Identifier",
+    IfStatement = "IfStatement",
+    ImportDeclaration = "ImportDeclaration",
+    ImportExpression = "ImportExpression",
+    ImportDefaultSpecifier = "ImportDefaultSpecifier",
+    ImportNamespaceSpecifier = "ImportNamespaceSpecifier",
+    ImportSpecifier = "ImportSpecifier",
+    LabeledStatement = "LabeledStatement",
+    Literal = "Literal",
+    LogicalExpression = "LogicalExpression",
+    MemberExpression = "MemberExpression",
+    MethodDefinition = "MethodDefinition",
+    NewExpression = "NewExpression",
+    ObjectExpression = "ObjectExpression",
+    ObjectPattern = "ObjectPattern",
+    Program = "Program",
+    Property = "Property",
+    PropertyDefinition = "PropertyDefinition",
+    RestElement = "RestElement",
+    ReturnStatement = "ReturnStatement",
+    SequenceExpression = "SequenceExpression",
+    SpreadElement = "SpreadElement",
+    Super = "Super",
+    SwitchCase = "SwitchCase",
+    SwitchStatement = "SwitchStatement",
+    TaggedTemplateExpression = "TaggedTemplateExpression",
+    TemplateElement = "TemplateElement",
+    TemplateLiteral = "TemplateLiteral",
+    ThisExpression = "ThisExpression",
+    ThrowStatement = "ThrowStatement",
+    TryStatement = "TryStatement",
+    UnaryExpression = "UnaryExpression",
+    UpdateExpression = "UpdateExpression",
+    VariableDeclaration = "VariableDeclaration",
+    VariableDeclarator = "VariableDeclarator",
+    WithStatement = "WithStatement",
+    WhileStatement = "WhileStatement",
+    YieldExpression = "YieldExpression"
+}

package/typings/src/enums/node/ObfuscatingGuardResult.d.ts

@@ -0,0 +1,5 @@
+export declare enum ObfuscatingGuardResult {
+    ForceTransform = "ForceTransform",
+    Ignore = "Ignore",
+    Transform = "Transform"
+}

package/typings/src/enums/node-transformers/NodeTransformationStage.d.ts

@@ -0,0 +1,12 @@
+export declare enum NodeTransformationStage {
+    ControlFlowFlattening = "ControlFlowFlattening",
+    Converting = "Converting",
+    DeadCodeInjection = "DeadCodeInjection",
+    Finalizing = "Finalizing",
+    Initializing = "Initializing",
+    Preparing = "Preparing",
+    RenameIdentifiers = "RenameIdentifiers",
+    RenameProperties = "RenameProperties",
+    Simplifying = "Simplifying",
+    StringArray = "StringArray"
+}

package/typings/src/enums/node-transformers/NodeTransformer.d.ts

@@ -0,0 +1,37 @@
+export declare enum NodeTransformer {
+    BooleanLiteralTransformer = "BooleanLiteralTransformer",
+    BlockStatementControlFlowTransformer = "BlockStatementControlFlowTransformer",
+    BlockStatementSimplifyTransformer = "BlockStatementSimplifyTransformer",
+    ClassFieldTransformer = "ClassFieldTransformer",
+    CommentsTransformer = "CommentsTransformer",
+    CustomCodeHelpersTransformer = "CustomCodeHelpersTransformer",
+    DeadCodeInjectionIdentifiersTransformer = "DeadCodeInjectionIdentifiersTransformer",
+    DeadCodeInjectionTransformer = "DeadCodeInjectionTransformer",
+    DirectivePlacementTransformer = "DirectivePlacementTransformer",
+    EscapeSequenceTransformer = "EscapeSequenceTransformer",
+    EvalCallExpressionTransformer = "EvalCallExpressionTransformer",
+    ExportSpecifierTransformer = "ExportSpecifierTransformer",
+    ExpressionStatementsMergeTransformer = "ExpressionStatementsMergeTransformer",
+    FunctionControlFlowTransformer = "FunctionControlFlowTransformer",
+    IfStatementSimplifyTransformer = "IfStatementSimplifyTransformer",
+    LabeledStatementTransformer = "LabeledStatementTransformer",
+    MemberExpressionTransformer = "MemberExpressionTransformer",
+    MetadataTransformer = "MetadataTransformer",
+    NumberLiteralTransformer = "NumberLiteralTransformer",
+    NumberToNumericalExpressionTransformer = "NumberToNumericalExpressionTransformer",
+    ObfuscatingGuardsTransformer = "ObfuscatingGuardsTransformer",
+    ObjectExpressionKeysTransformer = "ObjectExpressionKeysTransformer",
+    ObjectExpressionTransformer = "ObjectExpressionTransformer",
+    ObjectPatternPropertiesTransformer = "ObjectPatternPropertiesTransformer",
+    ParentificationTransformer = "ParentificationTransformer",
+    RenamePropertiesTransformer = "RenamePropertiesTransformer",
+    ScopeIdentifiersTransformer = "ScopeIdentifiersTransformer",
+    ScopeThroughIdentifiersTransformer = "ScopeThroughIdentifiersTransformer",
+    SplitStringTransformer = "SplitStringTransformer",
+    StringArrayTransformer = "StringArrayTransformer",
+    StringArrayRotateFunctionTransformer = "StringArrayRotateFunctionTransformer",
+    StringArrayScopeCallsWrapperTransformer = "StringArrayScopeCallsWrapperTransformer",
+    TemplateLiteralTransformer = "TemplateLiteralTransformer",
+    VariableDeclarationsMergeTransformer = "VariableDeclarationsMergeTransformer",
+    VariablePreserveTransformer = "VariablePreserveTransformer"
+}

package/typings/src/enums/node-transformers/VisitorDirection.d.ts

@@ -0,0 +1,4 @@
+export declare enum VisitorDirection {
+    Enter = "enter",
+    Leave = "leave"
+}

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

@@ -0,0 +1,6 @@
+export declare enum ControlFlowReplacer {
+    BinaryExpressionControlFlowReplacer = "BinaryExpressionControlFlowReplacer",
+    CallExpressionControlFlowReplacer = "CallExpressionControlFlowReplacer",
+    LogicalExpressionControlFlowReplacer = "LogicalExpressionControlFlowReplacer",
+    StringLiteralControlFlowReplacer = "StringLiteralControlFlowReplacer"
+}

package/typings/src/enums/node-transformers/converting-transformers/properties-extractors/ObjectExpressionExtractor.d.ts

@@ -0,0 +1,4 @@
+export declare enum ObjectExpressionExtractor {
+    BasePropertiesExtractor = "BasePropertiesExtractor",
+    ObjectExpressionToVariableDeclarationExtractor = "ObjectExpressionToVariableDeclarationExtractor"
+}

package/typings/src/enums/node-transformers/preparing-transformers/obfuscating-guards/ObfuscatingGuard.d.ts

@@ -0,0 +1,7 @@
+export declare enum ObfuscatingGuard {
+    BlackListObfuscatingGuard = "BlackListObfuscatingGuard",
+    ConditionalCommentObfuscatingGuard = "ConditionalCommentObfuscatingGuard",
+    ForceTransformStringObfuscatingGuard = "ForceTransformStringObfuscatingGuard",
+    IgnoredImportObfuscatingGuard = "IgnoredImportObfuscatingGuard",
+    ReservedStringObfuscatingGuard = "ReservedStringObfuscatingGuard"
+}

package/typings/src/enums/node-transformers/rename-properties-transformers/RenamePropertiesMode.d.ts

@@ -0,0 +1,4 @@
+export declare const RenamePropertiesMode: Readonly<{
+    Safe: 'safe';
+    Unsafe: 'unsafe';
+}>;

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

@@ -0,0 +1,5 @@
+export declare const StringArrayEncoding: Readonly<{
+    None: 'none';
+    Base64: 'base64';
+    Rc4: 'rc4';
+}>;

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

@@ -0,0 +1,4 @@
+export declare const StringArrayIndexesType: Readonly<{
+    HexadecimalNumber: 'hexadecimal-number';
+    HexadecimalNumericString: 'hexadecimal-numeric-string';
+}>;

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

@@ -0,0 +1,4 @@
+export declare const StringArrayWrappersType: Readonly<{
+    Variable: 'variable';
+    Function: 'function';
+}>;

package/typings/src/enums/options/presets/OptionsPreset.d.ts

@@ -0,0 +1,6 @@
+export declare const OptionsPreset: Readonly<{
+    Default: 'default';
+    LowObfuscation: 'low-obfuscation';
+    MediumObfuscation: 'medium-obfuscation';
+    HighObfuscation: 'high-obfuscation';
+}>;

package/typings/src/enums/source-map/SourceMapMode.d.ts

@@ -0,0 +1,4 @@
+export declare const SourceMapMode: Readonly<{
+    Inline: 'inline';
+    Separate: 'separate';
+}>;

package/typings/src/enums/source-map/SourceMapSourcesMode.d.ts

@@ -0,0 +1,4 @@
+export declare const SourceMapSourcesMode: Readonly<{
+    Sources: 'sources';
+    SourcesContent: 'sources-content';
+}>;

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

@@ -0,0 +1,20 @@
+import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
+import { IIdentifierNamesGenerator } from '../../interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+export declare abstract class AbstractIdentifierNamesGenerator implements IIdentifierNamesGenerator {
+    protected readonly options: IOptions;
+    protected readonly randomGenerator: IRandomGenerator;
+    protected readonly preservedNamesSet: Set<string>;
+    protected readonly lexicalScopesPreservedNamesMap: Map<TNodeWithLexicalScope, Set<string>>;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    generate(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    preserveName(name: string): void;
+    preserveNameForLexicalScope(name: string, lexicalScopeNode: TNodeWithLexicalScope): void;
+    isValidIdentifierName(name: string): boolean;
+    isValidIdentifierNameInLexicalScopes(name: string, lexicalScopeNodes: TNodeWithLexicalScope[]): boolean;
+    private notReservedName;
+    abstract generateForGlobalScope(nameLength?: number): string;
+    abstract generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    abstract generateNext(nameLength?: number): string;
+}

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

@@ -0,0 +1,18 @@
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { AbstractIdentifierNamesGenerator } from './AbstractIdentifierNamesGenerator';
+import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
+export declare class DictionaryIdentifierNamesGenerator extends AbstractIdentifierNamesGenerator {
+    private readonly arrayUtils;
+    private identifierNamesSet;
+    private identifiersIterator;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions, arrayUtils: IArrayUtils);
+    private static incrementIdentifierName;
+    generateNext(): string;
+    generateForGlobalScope(): string;
+    generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope): string;
+    private generateNewDictionaryName;
+    private getInitialIdentifierNames;
+    private getIncrementedIdentifierNames;
+}