javascript-obfuscator 2.18.0 → 3.0.0

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

@@ -0,0 +1,11 @@
+import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { AbstractIdentifierNamesGenerator } from './AbstractIdentifierNamesGenerator';
+export declare class HexadecimalIdentifierNamesGenerator extends AbstractIdentifierNamesGenerator {
+    private static readonly baseIdentifierNameLength;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    generateNext(nameLength?: number): string;
+    generateForGlobalScope(nameLength?: number): string;
+    generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+}

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

@@ -0,0 +1,21 @@
+import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { AbstractIdentifierNamesGenerator } from './AbstractIdentifierNamesGenerator';
+export declare class MangledIdentifierNamesGenerator extends AbstractIdentifierNamesGenerator {
+    private static readonly initMangledNameCharacter;
+    private static readonly lastMangledNameInScopeMap;
+    private static readonly nameSequence;
+    private static readonly reservedNamesSet;
+    private previousMangledName;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    generateNext(nameLength?: number): string;
+    generateForGlobalScope(nameLength?: number): string;
+    generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    isIncrementedMangledName(nextName: string, prevName: string): boolean;
+    isValidIdentifierName(mangledName: string): boolean;
+    protected getNameSequence(): string[];
+    protected updatePreviousMangledName(name: string): void;
+    protected generateNewMangledName(previousMangledName: string): string;
+    private getLastMangledNameForScopes;
+}

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

@@ -0,0 +1,13 @@
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { MangledIdentifierNamesGenerator } from './MangledIdentifierNamesGenerator';
+export declare class MangledShuffledIdentifierNamesGenerator extends MangledIdentifierNamesGenerator {
+    protected static shuffledNameSequence: string[];
+    private readonly arrayUtils;
+    constructor(arrayUtils: IArrayUtils, randomGenerator: IRandomGenerator, options: IOptions);
+    initialize(): void;
+    protected initializeNameSequence(nameSequence: string[]): void;
+    protected getNameSequence(): string[];
+    protected generateNewMangledName(previousMangledName: string): string;
+}

package/{src/interfaces/IEncodedValue.ts → typings/src/interfaces/IEncodedValue.d.ts}

@@ -1,5 +1,4 @@
 import { TStringArrayEncoding } from '../types/options/TStringArrayEncoding';
-
 export interface IEncodedValue {
     encoding: TStringArrayEncoding;
     encodedValue: string;

package/typings/src/interfaces/IInitializable.d.ts

@@ -0,0 +1,4 @@
+export interface IInitializable<T extends unknown[] = never[]> {
+    [key: string]: any;
+    initialize(...args: T): void;
+}

package/typings/src/interfaces/IJavaScriptObfsucator.d.ts

@@ -0,0 +1,4 @@
+import { IObfuscationResult } from './source-code/IObfuscationResult';
+export interface IJavaScriptObfuscator {
+    obfuscate(sourceCode: string): IObfuscationResult;
+}

package/typings/src/interfaces/ITransformer.d.ts

@@ -0,0 +1,3 @@
+export interface ITransformer<TTransformerName extends string> {
+    runAfter?: TTransformerName[];
+}

package/typings/src/interfaces/analyzers/IAnalyzer.d.ts

@@ -0,0 +1,3 @@
+export interface IAnalyzer<TArgs extends unknown[], TData extends unknown> {
+    analyze(...args: TArgs): TData;
+}

package/{src/interfaces/analyzers/calls-graph-analyzer/ICalleeData.ts → typings/src/interfaces/analyzers/calls-graph-analyzer/ICalleeData.d.ts}

@@ -1,5 +1,4 @@
 import * as ESTree from 'estree';
-
 export interface ICalleeData {
     callee: ESTree.BlockStatement;
     name: string | number | null;

package/typings/src/interfaces/analyzers/calls-graph-analyzer/ICalleeDataExtractor.d.ts

@@ -0,0 +1,5 @@
+import * as ESTree from 'estree';
+import { ICalleeData } from './ICalleeData';
+export interface ICalleeDataExtractor {
+    extract(blockScopeBody: ESTree.Node[], callee: ESTree.Node): ICalleeData | null;
+}

package/{src/interfaces/analyzers/calls-graph-analyzer/ICallsGraphAnalyzer.ts → typings/src/interfaces/analyzers/calls-graph-analyzer/ICallsGraphAnalyzer.d.ts}

@@ -1,12 +1,6 @@
 import * as ESTree from 'estree';
-
 import { IAnalyzer } from '../IAnalyzer';
 import { ICallsGraphData } from './ICallsGraphData';
-
 export interface ICallsGraphAnalyzer extends IAnalyzer<[ESTree.Program], ICallsGraphData[]> {
-    /**
-     * @param {Program} astTree
-     * @returns {ICallsGraphData[]}
-     */
-    analyze (astTree: ESTree.Program): ICallsGraphData[];
+    analyze(astTree: ESTree.Program): ICallsGraphData[];
 }

package/{src/interfaces/analyzers/calls-graph-analyzer/ICallsGraphData.ts → typings/src/interfaces/analyzers/calls-graph-analyzer/ICallsGraphData.d.ts}

@@ -1,5 +1,4 @@
 import { ICalleeData } from './ICalleeData';
-
 export interface ICallsGraphData extends ICalleeData {
     callsGraph: ICallsGraphData[];
 }

package/typings/src/interfaces/analyzers/calls-graph-analyzer/IPrevailingKindOfVariablesAnalyzer.d.ts

@@ -0,0 +1,6 @@
+import * as ESTree from 'estree';
+import { IAnalyzer } from '../IAnalyzer';
+export interface IPrevailingKindOfVariablesAnalyzer extends IAnalyzer<[ESTree.Program], void> {
+    analyze(astTree: ESTree.Program): void;
+    getPrevailingKind(): ESTree.VariableDeclaration['kind'];
+}

package/{src/interfaces/analyzers/number-numerical-expression-analyzer/INumberNumericalExpressionAnalyzer.ts → typings/src/interfaces/analyzers/number-numerical-expression-analyzer/INumberNumericalExpressionAnalyzer.d.ts}

@@ -1,15 +1,5 @@
 import { TNumberNumericalExpressionData } from '../../../types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
-
 import { IAnalyzer } from '../IAnalyzer';
-
 export interface INumberNumericalExpressionAnalyzer extends IAnalyzer<[number, number], TNumberNumericalExpressionData> {
-    /**
-     * @param {number} number
-     * @param {number} additionalPartsCount
-     * @returns {TNumberNumericalExpressionData}
-     */
-    analyze (
-        number: number,
-        additionalPartsCount: number
-    ): TNumberNumericalExpressionData;
+    analyze(number: number, additionalPartsCount: number): TNumberNumericalExpressionData;
 }

package/typings/src/interfaces/analyzers/scope-analyzer/IScopeAnalyzer.d.ts

@@ -0,0 +1,7 @@
+import * as eslintScope from 'eslint-scope';
+import * as ESTree from 'estree';
+import { IAnalyzer } from '../IAnalyzer';
+export interface IScopeAnalyzer extends IAnalyzer<[ESTree.Node], void> {
+    analyze(astTree: ESTree.Node): void;
+    acquireScope(node: ESTree.Node): eslintScope.Scope;
+}

package/typings/src/interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer.d.ts

@@ -0,0 +1,10 @@
+import * as ESTree from 'estree';
+import { TStringLiteralNode } from '../../../types/node/TStringLiteralNode';
+import { IAnalyzer } from '../IAnalyzer';
+import { IStringArrayStorageItemData } from '../../storages/string-array-transformers/IStringArrayStorageItem';
+export interface IStringArrayStorageAnalyzer extends IAnalyzer<[ESTree.Program], void> {
+    analyze(astTree: ESTree.Program): void;
+    analyzeLiteralNode(literalNode: ESTree.Literal, parentNode: ESTree.Node): void;
+    addItemDataForLiteralNode(stringLiteralNode: TStringLiteralNode): void;
+    getItemDataForLiteralNode(literalNode: ESTree.Literal): IStringArrayStorageItemData | undefined;
+}

package/typings/src/interfaces/code-transformers/ICodeTransformer.d.ts

@@ -0,0 +1,6 @@
+import { ITransformer } from '../ITransformer';
+import { CodeTransformer } from '../../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../../enums/code-transformers/CodeTransformationStage';
+export interface ICodeTransformer extends ITransformer<CodeTransformer> {
+    transformCode(code: string, codeTransformationStage: CodeTransformationStage): string;
+}

package/typings/src/interfaces/code-transformers/ICodeTransformersRunner.d.ts

@@ -0,0 +1,5 @@
+import { CodeTransformer } from '../../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../../enums/code-transformers/CodeTransformationStage';
+export interface ICodeTransformersRunner {
+    transform(code: string, codeTransformers: CodeTransformer[], codeTransformationStage: CodeTransformationStage): string;
+}

package/typings/src/interfaces/container/IInversifyContainerFacade.d.ts

@@ -0,0 +1,8 @@
+import { interfaces } from 'inversify';
+import { TInputOptions } from '../../types/options/TInputOptions';
+export interface IInversifyContainerFacade {
+    get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
+    getNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T;
+    load(sourceCode: string, sourceMap: string, options: TInputOptions): void;
+    unload(): void;
+}

package/typings/src/interfaces/custom-code-helpers/ICustomCodeHelper.d.ts

@@ -0,0 +1,5 @@
+import { TStatement } from '../../types/node/TStatement';
+import { IInitializable } from '../IInitializable';
+export interface ICustomCodeHelper<TInitialData extends unknown[] = unknown[]> extends IInitializable<TInitialData> {
+    getNode(): TStatement[];
+}

package/typings/src/interfaces/custom-code-helpers/ICustomCodeHelperFormatter.d.ts

@@ -0,0 +1,6 @@
+import { TDictionary } from '../../types/TDictionary';
+import { TStatement } from '../../types/node/TStatement';
+export interface ICustomCodeHelperFormatter {
+    formatTemplate<TMapping extends TDictionary>(template: string, mapping: TMapping): string;
+    formatStructure(structure: TStatement[]): TStatement[];
+}

package/{src/interfaces/custom-code-helpers/ICustomCodeHelperGroup.ts → typings/src/interfaces/custom-code-helpers/ICustomCodeHelperGroup.d.ts}

@@ -1,15 +1,8 @@
 import { TCustomCodeHelpersGroupAppendMethods } from '../../types/custom-code-helpers/TCustomCodeHelpersGroupAppendMethods';
-
 import { ICustomCodeHelper } from './ICustomCodeHelper';
 import { IInitializable } from '../IInitializable';
-
 import { CustomCodeHelper } from '../../enums/custom-code-helpers/CustomCodeHelper';
-
 export interface ICustomCodeHelperGroup extends IInitializable, TCustomCodeHelpersGroupAppendMethods {
-    /**
-     * @type {Map <CustomCodeHelper, ICustomCodeHelper>}
-     */
-    getCustomCodeHelpers (): Map <CustomCodeHelper, ICustomCodeHelper>;
-
-    initialize (): void;
+    getCustomCodeHelpers(): Map<CustomCodeHelper, ICustomCodeHelper>;
+    initialize(): void;
 }

package/typings/src/interfaces/custom-code-helpers/ICustomCodeHelperObfuscator.d.ts

@@ -0,0 +1,4 @@
+import { TInputOptions } from '../../types/options/TInputOptions';
+export interface ICustomCodeHelperObfuscator {
+    obfuscateTemplate(template: string, additionalOptions?: TInputOptions): string;
+}

package/typings/src/interfaces/custom-nodes/ICustomNode.d.ts

@@ -0,0 +1,5 @@
+import { TStatement } from '../../types/node/TStatement';
+import { IInitializable } from '../IInitializable';
+export interface ICustomNode<TInitialData extends unknown[] = unknown[]> extends IInitializable<TInitialData> {
+    getNode(): TStatement[];
+}

package/{src/interfaces/custom-nodes/string-array-nodes/IStringArrayIndexNode.ts → typings/src/interfaces/custom-nodes/string-array-nodes/IStringArrayIndexNode.d.ts}

@@ -1,5 +1,4 @@
 import * as ESTree from 'estree';
-
 export interface IStringArrayIndexNode {
     getNode: (index: number) => ESTree.Expression;
 }

package/typings/src/interfaces/generators/identifier-names-generators/IIdentifierNamesGenerator.d.ts

@@ -0,0 +1,11 @@
+import { TNodeWithLexicalScope } from '../../../types/node/TNodeWithLexicalScope';
+export interface IIdentifierNamesGenerator {
+    generate(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    generateForGlobalScope(nameLength?: number): string;
+    generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
+    generateNext(nameLength?: number): string;
+    isValidIdentifierName(identifierName: string): boolean;
+    isValidIdentifierNameInLexicalScopes(identifierName: string, lexicalScopeNodes: TNodeWithLexicalScope[]): boolean;
+    preserveName(identifierName: string): void;
+    preserveNameForLexicalScope(identifierName: string, lexicalScope: TNodeWithLexicalScope): void;
+}

package/typings/src/interfaces/logger/ILogger.d.ts

@@ -0,0 +1,6 @@
+import { LoggingMessage } from '../../enums/logger/LoggingMessage';
+export interface ILogger {
+    info(loggingMessage: LoggingMessage, value?: string | number): void;
+    success(loggingMessage: LoggingMessage, value?: string | number): void;
+    warn(loggingMessage: LoggingMessage, value?: string | number): void;
+}

package/typings/src/interfaces/node/IScopeIdentifiersTraverser.d.ts

@@ -0,0 +1,8 @@
+import * as ESTree from 'estree';
+import { TScopeIdentifiersTraverserCallback } from '../../types/node/TScopeIdentifiersTraverserCallback';
+import { IScopeIdentifiersTraverserCallbackData } from './IScopeIdentifiersTraverserCallbackData';
+import { IScopeThroughIdentifiersTraverserCallbackData } from './IScopeThroughIdentifiersTraverserCallbackData';
+export interface IScopeIdentifiersTraverser {
+    traverseScopeIdentifiers(programNode: ESTree.Program, parentNode: ESTree.Node | null, callback: TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>): void;
+    traverseScopeThroughIdentifiers(node: ESTree.Node, parentNode: ESTree.Node | null, callback: TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>): void;
+}

package/{src/interfaces/node/IScopeIdentifiersTraverserCallbackData.ts → typings/src/interfaces/node/IScopeIdentifiersTraverserCallbackData.d.ts}

@@ -1,7 +1,5 @@
 import * as eslintScope from 'eslint-scope';
-
 import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-
 export interface IScopeIdentifiersTraverserCallbackData {
     isGlobalDeclaration: boolean;
     isBubblingDeclaration: boolean;

package/{src/interfaces/node/IScopeThroughIdentifiersTraverserCallbackData.ts → typings/src/interfaces/node/IScopeThroughIdentifiersTraverserCallbackData.d.ts}

@@ -1,7 +1,5 @@
 import * as eslintScope from 'eslint-scope';
-
 import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-
 export interface IScopeThroughIdentifiersTraverserCallbackData {
     isGlobalDeclaration: boolean;
     reference: eslintScope.Reference;

package/typings/src/interfaces/node-transformers/INodeTransformer.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="estraverse" />
+import * as estraverse from '@javascript-obfuscator/estraverse';
+import * as ESTree from 'estree';
+import { ITransformer } from '../ITransformer';
+import { IVisitor } from './IVisitor';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+export interface INodeTransformer extends ITransformer<NodeTransformer> {
+    getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
+    prepareNode?(node: ESTree.Node, parentNode: ESTree.Node | null): void;
+    restoreNode?(node: ESTree.Node, parentNode: ESTree.Node | null): void;
+    transformNode(node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | estraverse.VisitorOption;
+}

package/typings/src/interfaces/node-transformers/INodeTransformersRunner.d.ts

@@ -0,0 +1,6 @@
+import * as ESTree from 'estree';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
+import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+export interface INodeTransformersRunner {
+    transform<T extends ESTree.Node = ESTree.Program>(astTree: T, nodeTransformers: NodeTransformer[], nodeTransformationStage: NodeTransformationStage): T;
+}

package/typings/src/interfaces/node-transformers/IVisitor.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="estraverse" />
+import * as estraverse from '@javascript-obfuscator/estraverse';
+import * as ESTree from 'estree';
+export interface IVisitor<T extends ESTree.Node = ESTree.Node> {
+    enter?(node: T, parentNode: ESTree.Node | null): ESTree.Node | estraverse.VisitorOption | void;
+    leave?(node: T, parentNode: ESTree.Node | null): ESTree.Node | estraverse.VisitorOption | void;
+}

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

@@ -0,0 +1,5 @@
+import * as ESTree from 'estree';
+import { TControlFlowStorage } from '../../../types/storages/TControlFlowStorage';
+export interface IControlFlowReplacer {
+    replace(node: ESTree.Node, parentNode: ESTree.Node, controlFlowStorage: TControlFlowStorage): ESTree.Node;
+}

package/typings/src/interfaces/node-transformers/converting-transformers/object-expression-extractors/IObjectExpressionExtractor.d.ts

@@ -0,0 +1,5 @@
+import * as ESTree from 'estree';
+import { IObjectExpressionExtractorResult } from './IObjectExpressionExtractorResult';
+export interface IObjectExpressionExtractor {
+    extract(objectExpressionNode: ESTree.ObjectExpression, hostStatement: ESTree.Statement): IObjectExpressionExtractorResult;
+}

package/{src/interfaces/node-transformers/converting-transformers/object-expression-extractors/IObjectExpressionExtractorResult.ts → typings/src/interfaces/node-transformers/converting-transformers/object-expression-extractors/IObjectExpressionExtractorResult.d.ts}

@@ -1,18 +1,6 @@
 import * as ESTree from 'estree';
-
 export interface IObjectExpressionExtractorResult {
-    /**
-     * @type {Node}
-     */
     nodeToReplace: ESTree.Node;
-
-    /**
-     * @type {Statement}
-     */
     objectExpressionHostStatement: ESTree.Statement;
-
-    /**
-     * @type {ObjectExpression}
-     */
     objectExpressionNode: ESTree.ObjectExpression;
 }

package/{src/interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard.ts → typings/src/interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard.d.ts}

@@ -1,9 +1,4 @@
 import { TObfuscatingGuard } from '../../../../types/node/TObfuscatingGuard';
-
 export interface IObfuscatingGuard {
-    /**
-     * @param {Node} node
-     * @returns {boolean}
-     */
     check: TObfuscatingGuard;
 }

package/typings/src/interfaces/node-transformers/rename-identifiers-transformers/replacer/IIdentifierReplacer.d.ts

@@ -0,0 +1,9 @@
+import * as ESTree from 'estree';
+import { TNodeWithLexicalScope } from '../../../../types/node/TNodeWithLexicalScope';
+export interface IIdentifierReplacer {
+    storeGlobalName(identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): void;
+    storeLocalName(identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): void;
+    replace(node: ESTree.Node, lexicalScopeNode?: TNodeWithLexicalScope, nodeIdentifier?: number): ESTree.Identifier;
+    preserveName(identifierNode: ESTree.Identifier): void;
+    preserveNameForLexicalScope(identifierNode: ESTree.Identifier, lexicalScopeNode: TNodeWithLexicalScope): void;
+}

package/typings/src/interfaces/node-transformers/rename-identifiers-transformers/replacer/IThroughIdentifierReplacer.d.ts

@@ -0,0 +1,4 @@
+import * as ESTree from 'estree';
+export interface IThroughIdentifierReplacer {
+    replace(identifierNode: ESTree.Identifier): ESTree.Identifier;
+}

package/typings/src/interfaces/node-transformers/rename-properties-transformers/replacer/IRenamePropertiesReplacer.d.ts

@@ -0,0 +1,5 @@
+import * as ESTree from 'estree';
+export interface IRenamePropertiesReplacer {
+    excludePropertyName(propertyName: string): void;
+    replace(node: ESTree.Identifier | ESTree.Literal): ESTree.Identifier | ESTree.Literal;
+}

package/{src/interfaces/node-transformers/simplifying-transformers/IIteratedStatementsSimplifyData.ts → typings/src/interfaces/node-transformers/simplifying-transformers/IIteratedStatementsSimplifyData.d.ts}

@@ -1,18 +1,6 @@
 import * as ESTree from 'estree';
-
 export interface IIteratedStatementsSimplifyData {
-    /**
-     * @type {number | null}
-     */
     startIndex: number | null;
-
-    /**
-     * @type {ESTree.Expression[]}
-     */
     unwrappedExpressions: ESTree.Expression[];
-
-    /**
-     * @type {boolean}
-     */
     hasReturnStatement: boolean;
 }

package/{src/interfaces/node-transformers/simplifying-transformers/IStatementSimplifyData.ts → typings/src/interfaces/node-transformers/simplifying-transformers/IStatementSimplifyData.d.ts}

@@ -1,30 +1,10 @@
 import * as ESTree from 'estree';
-
 export interface IStatementSimplifyData {
-    /**
-     * @type {ESTree.Statement[]}
-     */
     leadingStatements: ESTree.Statement[];
-
     trailingStatement: {
-        /**
-         * @type {ESTree.Statement | null}
-         */
         statement: ESTree.Statement;
-
-        /**
-         * @type {ESTree.Expression | null}
-         */
         expression: ESTree.Expression;
     } | null;
-
-    /**
-     * @type {boolean}
-     */
     hasReturnStatement: boolean;
-
-    /**
-     * @type {boolean}
-     */
     hasSingleExpression: boolean;
 }

package/{src/interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperData.ts → typings/src/interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperData.d.ts}

@@ -1,18 +1,6 @@
 import { IStringArrayScopeCallsWrapperParameterIndexesData } from './IStringArrayScopeCallsWrapperParameterIndexesData';
-
 export interface IStringArrayScopeCallsWrapperData {
-    /**
-     * @type {number}
-     */
     index: number;
-
-    /**
-     * @type {string}
-     */
     name: string;
-
-    /**
-     * @type {IStringArrayScopeCallsWrapperParameterIndexesData | null}
-     */
     parameterIndexesData: IStringArrayScopeCallsWrapperParameterIndexesData | null;
 }

package/{src/interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperParameterIndexesData.ts → typings/src/interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrapperParameterIndexesData.d.ts}

@@ -1,11 +1,4 @@
 export interface IStringArrayScopeCallsWrapperParameterIndexesData {
-    /**
-     * @type {number}
-     */
     valueIndexParameterIndex: number;
-
-    /**
-     * @type {number}
-     */
     decodeKeyParameterIndex: number;
 }

package/{src/interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrappersData.ts → typings/src/interfaces/node-transformers/string-array-transformers/IStringArrayScopeCallsWrappersData.d.ts}

@@ -1,15 +1,6 @@
 import { TStringArrayEncoding } from '../../../types/options/TStringArrayEncoding';
-
 import { IStringArrayScopeCallsWrapperData } from './IStringArrayScopeCallsWrapperData';
-
 export interface IStringArrayScopeCallsWrappersData {
-    /**
-     * @type {TStringArrayEncoding}
-     */
     encoding: TStringArrayEncoding;
-
-    /**
-     * @type {string[]}
-     */
     scopeCallsWrappersData: IStringArrayScopeCallsWrapperData[];
 }

package/{src/interfaces/options/ICLIOptions.ts → typings/src/interfaces/options/ICLIOptions.d.ts}

@@ -1,5 +1,4 @@
 import { IOptions } from './IOptions';
-
 export interface ICLIOptions extends IOptions {
     readonly config: string;
     readonly exclude: string[];

package/{src/interfaces/options/IOptions.ts → typings/src/interfaces/options/IOptions.d.ts}

@@ -5,12 +5,10 @@ import { TStringArrayEncoding } from '../../types/options/TStringArrayEncoding';
 import { TStringArrayWrappersType } from '../../types/options/TStringArrayWrappersType';
 import { TRenamePropertiesMode } from '../../types/options/TRenamePropertiesMode';
 import { TTypeFromEnum } from '../../types/utils/TTypeFromEnum';
-
 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 interface IOptions {
     readonly compact: boolean;
     readonly controlFlowFlattening: boolean;
@@ -27,7 +25,7 @@ export interface IOptions {
     readonly identifierNamesGenerator: TTypeFromEnum<typeof IdentifierNamesGenerator>;
     readonly identifiersDictionary: string[];
     readonly identifiersPrefix: string;
-    readonly ignoreRequireImports: boolean;
+    readonly ignoreImports: boolean;
     readonly inputFileName: string;
     readonly log: boolean;
     readonly numbersToExpressions: boolean;
@@ -37,10 +35,8 @@ export interface IOptions {
     readonly renamePropertiesMode: TRenamePropertiesMode;
     readonly reservedNames: string[];
     readonly reservedStrings: string[];
-    readonly rotateStringArray: boolean;
     readonly seed: string | number;
     readonly selfDefending: boolean;
-    readonly shuffleStringArray: boolean;
     readonly simplify: boolean;
     readonly sourceMap: boolean;
     readonly sourceMapBaseUrl: string;
@@ -53,6 +49,8 @@ export interface IOptions {
     readonly stringArrayEncoding: TStringArrayEncoding[];
     readonly stringArrayIndexesType: TStringArrayIndexesType[];
     readonly stringArrayIndexShift: boolean;
+    readonly stringArrayRotate: boolean;
+    readonly stringArrayShuffle: boolean;
     readonly stringArrayWrappersChainedCalls: boolean;
     readonly stringArrayWrappersCount: number;
     readonly stringArrayWrappersParametersMaxCount: number;

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> {
+}