javascript-obfuscator 2.18.0 → 3.0.0

package/index.ts

@@ -1,5 +1,44 @@
 "use strict";
 
+import { TDictionary } from './src/types/TDictionary';
+import { TInputOptions } from './src/types/options/TInputOptions';
+import { TObfuscationResultsObject } from './src/types/TObfuscationResultsObject';
+import { TOptionsPreset } from './src/types/options/TOptionsPreset';
+
+import { IObfuscationResult } from './src/interfaces/source-code/IObfuscationResult';
+
 import { JavaScriptObfuscator } from './src/JavaScriptObfuscatorFacade';
 
+export type ObfuscatorOptions = TInputOptions;
+
+export interface ObfuscationResult extends IObfuscationResult {}
+
+/**
+ * @param {string} sourceCode
+ * @param {ObfuscatorOptions} inputOptions
+ * @returns {ObfuscatedCode}
+ */
+export declare function obfuscate (sourceCode: string, inputOptions?: ObfuscatorOptions): ObfuscationResult;
+
+/**
+ * @param {TSourceCodesObject} sourceCodesObject
+ * @param {TInputOptions} inputOptions
+ * @returns {TObfuscationResultsObject<TSourceCodesObject>}
+ */
+export declare function obfuscateMultiple <TSourceCodesObject extends TDictionary<string>> (
+    sourceCodesObject: TSourceCodesObject,
+    inputOptions?: TInputOptions
+): TObfuscationResultsObject<TSourceCodesObject>;
+
+/**
+ * @param {TOptionsPreset} optionsPreset
+ * @returns {TInputOptions}
+ */
+export declare function getOptionsByPreset (optionsPreset: TOptionsPreset): TInputOptions;
+
+/**
+ * @type {string}
+ */
+export declare const version: string;
+
 module.exports = JavaScriptObfuscator;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "2.18.0",
+  "version": "3.0.0",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -19,17 +19,17 @@
   "bin": {
     "javascript-obfuscator": "./bin/javascript-obfuscator"
   },
-  "types": "index.d.ts",
+  "types": "typings/index.d.ts",
   "dependencies": {
-    "@javascript-obfuscator/escodegen": "2.2.0",
+    "@javascript-obfuscator/escodegen": "2.2.2",
     "@javascript-obfuscator/estraverse": "5.3.0",
     "@nuxtjs/opencollective": "0.3.2",
-    "acorn": "8.4.1",
+    "acorn": "8.5.0",
     "assert": "2.0.0",
-    "chalk": "4.1.1",
-    "chance": "1.1.7",
+    "chalk": "4.1.2",
+    "chance": "1.1.8",
     "class-validator": "0.13.1",
-    "commander": "8.0.0",
+    "commander": "8.2.0",
     "eslint-scope": "6.0.0",
     "fast-deep-equal": "3.1.3",
     "inversify": "5.1.1",
@@ -39,33 +39,34 @@
     "multimatch": "5.0.0",
     "process": "0.11.10",
     "reflect-metadata": "0.1.13",
-    "source-map-support": "0.5.19",
+    "source-map-support": "0.5.20",
     "string-template": "1.0.0",
     "stringz": "2.1.0",
-    "tslib": "2.3.0"
+    "tslib": "2.3.1"
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "1.0.1",
-    "@types/chai": "4.2.21",
+    "@types/chai": "4.2.22",
     "@types/chance": "1.1.3",
     "@types/escodegen": "0.0.7",
     "@types/eslint-scope": "3.7.1",
     "@types/estraverse": "5.1.1",
     "@types/estree": "0.0.50",
-    "@types/js-string-escape": "1.0.0",
+    "@types/js-beautify": "1.13.3",
+    "@types/js-string-escape": "1.0.1",
     "@types/md5": "2.3.1",
     "@types/mkdirp": "1.0.2",
     "@types/mocha": "9.0.0",
     "@types/multimatch": "4.0.0",
-    "@types/node": "16.4.1",
-    "@types/rimraf": "3.0.1",
-    "@types/sinon": "10.0.2",
+    "@types/node": "16.11.0",
+    "@types/rimraf": "3.0.2",
+    "@types/sinon": "10.0.4",
     "@types/string-template": "1.0.2",
-    "@types/webpack-env": "1.16.2",
-    "@typescript-eslint/eslint-plugin": "4.28.4",
-    "@typescript-eslint/parser": "4.28.4",
+    "@types/webpack-env": "1.16.3",
+    "@typescript-eslint/eslint-plugin": "5.0.0",
+    "@typescript-eslint/parser": "5.0.0",
     "chai": "4.3.4",
-    "chai-exclude": "2.0.3",
+    "chai-exclude": "2.1.0",
     "cross-env": "7.0.3",
     "eslint": "7.31.0",
     "eslint-plugin-import": "2.23.4",
@@ -74,20 +75,22 @@
     "eslint-plugin-prefer-arrow": "1.2.3",
     "eslint-plugin-unicorn": "34.0.1",
     "fork-ts-checker-notifier-webpack-plugin": "4.0.0",
-    "fork-ts-checker-webpack-plugin": "6.2.12",
-    "mocha": "9.0.2",
+    "fork-ts-checker-webpack-plugin": "6.3.4",
+    "husky": "^7.0.2",
+    "js-beautify": "1.14.0",
+    "mocha": "9.1.3",
     "nyc": "15.1.0",
     "pjson": "1.0.9",
-    "pre-commit": "1.2.2",
     "rimraf": "3.0.2",
-    "sinon": "11.1.1",
-    "source-map-resolve": "^0.6.0",
-    "threads": "1.6.5",
-    "ts-loader": "9.2.3",
-    "ts-node": "10.1.0",
-    "typescript": "4.4.0-beta",
-    "webpack": "5.46.0",
-    "webpack-cli": "4.7.2",
+    "sinon": "11.1.2",
+    "source-map-resolve": "0.6.0",
+    "terser": "^5.9.0",
+    "threads": "1.7.0",
+    "ts-loader": "9.2.6",
+    "ts-node": "10.3.0",
+    "typescript": "4.4.4",
+    "webpack": "5.58.2",
+    "webpack-cli": "4.9.0",
     "webpack-node-externals": "3.0.0"
   },
   "repository": {
@@ -99,6 +102,7 @@
     "start": "yarn run watch",
     "webpack:prod": "webpack --config ./webpack/webpack.node.config.js --config ./webpack/webpack.browser.config.js --mode production",
     "build": "yarn run webpack:prod && yarn run eslint && yarn test",
+    "build:typings": "rm -rf ./typings && tsc --project src/tsconfig.typings.json",
     "watch": "webpack --config ./webpack/webpack.node.config.js --mode development --watch",
     "test:dev": "ts-node --type-check test/dev/dev.ts",
     "test:devCompilePerformance": "ts-node test/dev/dev-compile-performance.ts",
@@ -111,12 +115,11 @@
     "test": "yarn run test:full",
     "eslint": "eslint src/**/*.ts",
     "git:addFiles": "git add .",
-    "postinstall": "opencollective"
+    "postinstall": "opencollective",
+    "precommit": "npm run build",
+    "prepublishOnly": "npm run build && npm run build:typings",
+    "prepare": "husky install"
   },
-  "pre-commit": [
-    "build",
-    "git:addFiles"
-  ],
   "author": {
     "name": "Timofey Kachalov"
   },

package/typings/index.d.ts

@@ -0,0 +1,12 @@
+import { TDictionary } from './src/types/TDictionary';
+import { TInputOptions } from './src/types/options/TInputOptions';
+import { TObfuscationResultsObject } from './src/types/TObfuscationResultsObject';
+import { TOptionsPreset } from './src/types/options/TOptionsPreset';
+import { IObfuscationResult } from './src/interfaces/source-code/IObfuscationResult';
+export declare type ObfuscatorOptions = TInputOptions;
+export interface ObfuscationResult extends IObfuscationResult {
+}
+export declare function obfuscate(sourceCode: string, inputOptions?: ObfuscatorOptions): ObfuscationResult;
+export declare function obfuscateMultiple<TSourceCodesObject extends TDictionary<string>>(sourceCodesObject: TSourceCodesObject, inputOptions?: TInputOptions): TObfuscationResultsObject<TSourceCodesObject>;
+export declare function getOptionsByPreset(optionsPreset: TOptionsPreset): TInputOptions;
+export declare const version: string;

package/typings/src/ASTParserFacade.d.ts

@@ -0,0 +1,10 @@
+import * as acorn from 'acorn';
+import * as ESTree from 'estree';
+export declare class ASTParserFacade {
+    private static readonly colorError;
+    private static readonly nearestSymbolsCount;
+    private static readonly sourceTypes;
+    static parse(sourceCode: string, config: acorn.Options): ESTree.Program | never;
+    private static parseType;
+    private static processParsingError;
+}

package/typings/src/JavaScriptObfuscator.d.ts

@@ -0,0 +1,28 @@
+import { TObfuscationResultFactory } from './types/container/source-code/TObfuscationResultFactory';
+import { ICodeTransformersRunner } from './interfaces/code-transformers/ICodeTransformersRunner';
+import { IJavaScriptObfuscator } from './interfaces/IJavaScriptObfsucator';
+import { ILogger } from './interfaces/logger/ILogger';
+import { IObfuscationResult } from './interfaces/source-code/IObfuscationResult';
+import { IOptions } from './interfaces/options/IOptions';
+import { IRandomGenerator } from './interfaces/utils/IRandomGenerator';
+import { INodeTransformersRunner } from './interfaces/node-transformers/INodeTransformersRunner';
+export declare class JavaScriptObfuscator implements IJavaScriptObfuscator {
+    private static readonly parseOptions;
+    private static readonly escodegenParams;
+    private static readonly codeTransformersList;
+    private static readonly nodeTransformersList;
+    private readonly codeTransformersRunner;
+    private readonly logger;
+    private readonly obfuscationResultFactory;
+    private readonly options;
+    private readonly randomGenerator;
+    private readonly nodeTransformersRunner;
+    constructor(codeTransformersRunner: ICodeTransformersRunner, nodeTransformersRunner: INodeTransformersRunner, randomGenerator: IRandomGenerator, obfuscatedCodeFactory: TObfuscationResultFactory, logger: ILogger, options: IOptions);
+    obfuscate(sourceCode: string): IObfuscationResult;
+    private parseCode;
+    private transformAstTree;
+    private generateCode;
+    private getObfuscationResult;
+    private runCodeTransformationStage;
+    private runNodeTransformationStage;
+}

package/typings/src/JavaScriptObfuscatorCLIFacade.d.ts

@@ -0,0 +1,5 @@
+import 'reflect-metadata';
+declare class JavaScriptObfuscatorCLIFacade {
+    static obfuscate(argv: string[]): void;
+}
+export { JavaScriptObfuscatorCLIFacade as JavaScriptObfuscatorCLI };

package/typings/src/JavaScriptObfuscatorFacade.d.ts

@@ -0,0 +1,13 @@
+import 'reflect-metadata';
+import { TDictionary } from './types/TDictionary';
+import { TInputOptions } from './types/options/TInputOptions';
+import { TObfuscationResultsObject } from './types/TObfuscationResultsObject';
+import { TOptionsPreset } from './types/options/TOptionsPreset';
+import { IObfuscationResult } from './interfaces/source-code/IObfuscationResult';
+declare class JavaScriptObfuscatorFacade {
+    static version: string;
+    static obfuscate(sourceCode: string, inputOptions?: TInputOptions): IObfuscationResult;
+    static obfuscateMultiple<TSourceCodesObject extends TDictionary<string>>(sourceCodesObject: TSourceCodesObject, inputOptions?: TInputOptions): TObfuscationResultsObject<TSourceCodesObject>;
+    static getOptionsByPreset(optionsPreset: TOptionsPreset): TInputOptions;
+}
+export { JavaScriptObfuscatorFacade as JavaScriptObfuscator };

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

@@ -0,0 +1,15 @@
+import * as ESTree from 'estree';
+import { TCalleeDataExtractorFactory } from '../../types/container/calls-graph-analyzer/TCalleeDataExtractorFactory';
+import { ICallsGraphAnalyzer } from '../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphAnalyzer';
+import { ICallsGraphData } from '../../interfaces/analyzers/calls-graph-analyzer/ICallsGraphData';
+export declare class CallsGraphAnalyzer implements ICallsGraphAnalyzer {
+    private static readonly calleeDataExtractorsList;
+    private static readonly limitThresholdActivationLength;
+    private static readonly limitThreshold;
+    private readonly calleeDataExtractorFactory;
+    constructor(calleeDataExtractorFactory: TCalleeDataExtractorFactory);
+    static getLimitIndex(blockScopeBodyLength: number): number;
+    analyze(astTree: ESTree.Program): ICallsGraphData[];
+    private analyzeRecursive;
+    private analyzeCallExpressionNode;
+}

package/typings/src/analyzers/calls-graph-analyzer/callee-data-extractors/AbstractCalleeDataExtractor.d.ts

@@ -0,0 +1,6 @@
+import * as ESTree from 'estree';
+import { ICalleeData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
+import { ICalleeDataExtractor } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeDataExtractor';
+export declare abstract class AbstractCalleeDataExtractor implements ICalleeDataExtractor {
+    abstract extract(blockScopeBody: ESTree.Node[], callee: ESTree.Node): ICalleeData | null;
+}

package/typings/src/analyzers/calls-graph-analyzer/callee-data-extractors/FunctionDeclarationCalleeDataExtractor.d.ts

@@ -0,0 +1,7 @@
+import * as ESTree from 'estree';
+import { ICalleeData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
+import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
+export declare class FunctionDeclarationCalleeDataExtractor extends AbstractCalleeDataExtractor {
+    extract(blockScopeBody: ESTree.Node[], callee: ESTree.Identifier): ICalleeData | null;
+    private getCalleeBlockStatement;
+}

package/typings/src/analyzers/calls-graph-analyzer/callee-data-extractors/FunctionExpressionCalleeDataExtractor.d.ts

@@ -0,0 +1,7 @@
+import * as ESTree from 'estree';
+import { ICalleeData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
+import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
+export declare class FunctionExpressionCalleeDataExtractor extends AbstractCalleeDataExtractor {
+    extract(blockScopeBody: ESTree.Node[], callee: ESTree.Identifier | ESTree.FunctionExpression): ICalleeData | null;
+    private getCalleeBlockStatement;
+}

package/typings/src/analyzers/calls-graph-analyzer/callee-data-extractors/ObjectExpressionCalleeDataExtractor.d.ts

@@ -0,0 +1,10 @@
+import * as ESTree from 'estree';
+import { ICalleeData } from '../../../interfaces/analyzers/calls-graph-analyzer/ICalleeData';
+import { AbstractCalleeDataExtractor } from './AbstractCalleeDataExtractor';
+export declare class ObjectExpressionCalleeDataExtractor extends AbstractCalleeDataExtractor {
+    private static isValidTargetPropertyNode;
+    extract(blockScopeBody: ESTree.Node[], callee: ESTree.MemberExpression): ICalleeData | null;
+    private createObjectMembersCallsChain;
+    private getCalleeBlockStatement;
+    private findCalleeBlockStatement;
+}

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

@@ -0,0 +1,13 @@
+import { TNumberNumericalExpressionData } from '../../types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
+import { INumberNumericalExpressionAnalyzer } from '../../interfaces/analyzers/number-numerical-expression-analyzer/INumberNumericalExpressionAnalyzer';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+export declare class NumberNumericalExpressionAnalyzer implements INumberNumericalExpressionAnalyzer {
+    static readonly defaultAdditionalPartsCount: number;
+    private static readonly delta;
+    private readonly numberFactorsMap;
+    private readonly randomGenerator;
+    constructor(randomGenerator: IRandomGenerator);
+    analyze(number: number, additionalPartsCount: number): TNumberNumericalExpressionData;
+    private generateAdditionParts;
+    private mixWithMultiplyParts;
+}

package/typings/src/analyzers/prevailing-kind-of-variables-analyzer/PrevailingKindOfVariablesAnalyzer.d.ts

@@ -0,0 +1,11 @@
+import * as ESTree from 'estree';
+import { IArrayUtils } from '../../interfaces/utils/IArrayUtils';
+import { IPrevailingKindOfVariablesAnalyzer } from '../../interfaces/analyzers/calls-graph-analyzer/IPrevailingKindOfVariablesAnalyzer';
+export declare class PrevailingKindOfVariablesAnalyzer implements IPrevailingKindOfVariablesAnalyzer {
+    private static readonly defaultKindOfVariables;
+    private readonly arrayUtils;
+    private prevailingKindOfVariables;
+    constructor(arrayUtils: IArrayUtils);
+    analyze(astTree: ESTree.Program): void;
+    getPrevailingKind(): ESTree.VariableDeclaration['kind'];
+}

package/typings/src/analyzers/scope-analyzer/ScopeAnalyzer.d.ts

@@ -0,0 +1,14 @@
+import * as eslintScope from 'eslint-scope';
+import * as ESTree from 'estree';
+import { IScopeAnalyzer } from '../../interfaces/analyzers/scope-analyzer/IScopeAnalyzer';
+export declare class ScopeAnalyzer implements IScopeAnalyzer {
+    private static readonly eslintScopeOptions;
+    private static readonly sourceTypes;
+    private static readonly emptyRangeValue;
+    private scopeManager;
+    private static attachMissingRanges;
+    private static isRootNode;
+    analyze(astTree: ESTree.Node): void;
+    acquireScope(node: ESTree.Node): eslintScope.Scope;
+    private sanitizeScopes;
+}

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

@@ -0,0 +1,20 @@
+import * as ESTree from 'estree';
+import { TStringLiteralNode } from '../../types/node/TStringLiteralNode';
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { IStringArrayStorage } from '../../interfaces/storages/string-array-transformers/IStringArrayStorage';
+import { IStringArrayStorageAnalyzer } from '../../interfaces/analyzers/string-array-storage-analyzer/IStringArrayStorageAnalyzer';
+import { IStringArrayStorageItemData } from '../../interfaces/storages/string-array-transformers/IStringArrayStorageItem';
+export declare class StringArrayStorageAnalyzer implements IStringArrayStorageAnalyzer {
+    private static readonly minimumLengthForStringArray;
+    private readonly options;
+    private readonly randomGenerator;
+    private readonly stringArrayStorage;
+    private readonly stringArrayStorageData;
+    constructor(stringArrayStorage: IStringArrayStorage, randomGenerator: IRandomGenerator, options: IOptions);
+    analyze(astTree: ESTree.Program): void;
+    analyzeLiteralNode(literalNode: ESTree.Literal, parentNode: ESTree.Node): void;
+    addItemDataForLiteralNode(literalNode: TStringLiteralNode): void;
+    getItemDataForLiteralNode(literalNode: ESTree.Literal): IStringArrayStorageItemData | undefined;
+    private shouldAddValueToStringArray;
+}

package/typings/src/cli/JavaScriptObfuscatorCLI.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+import { IInitializable } from '../interfaces/IInitializable';
+export declare class JavaScriptObfuscatorCLI implements IInitializable {
+    static readonly availableInputExtensions: string[];
+    static readonly encoding: BufferEncoding;
+    static readonly obfuscatedFilePrefix: string;
+    private commands;
+    private identifierNamesCacheFileUtils;
+    private inputCLIOptions;
+    private inputPath;
+    private sourceCodeFileUtils;
+    private obfuscatedCodeFileUtils;
+    private readonly arguments;
+    private readonly rawArguments;
+    constructor(argv: string[]);
+    private static buildOptions;
+    private static filterOptions;
+    initialize(): void;
+    run(): void;
+    private configureCommands;
+    private configureHelp;
+    private processSourceCodeData;
+    private processSourceCode;
+    private processSourceCodeWithoutSourceMap;
+    private processSourceCodeWithSourceMap;
+}

package/typings/src/cli/sanitizers/ArraySanitizer.d.ts

@@ -0,0 +1,2 @@
+import { TCLISanitizer } from '../../types/cli/TCLISanitizer';
+export declare const ArraySanitizer: TCLISanitizer<string[]>;

package/typings/src/cli/sanitizers/BooleanSanitizer.d.ts

@@ -0,0 +1,2 @@
+import { TCLISanitizer } from '../../types/cli/TCLISanitizer';
+export declare const BooleanSanitizer: TCLISanitizer<boolean>;

package/typings/src/cli/utils/CLIUtils.d.ts

@@ -0,0 +1,6 @@
+import { TDictionary } from '../../types/TDictionary';
+export declare class CLIUtils {
+    static readonly allowedConfigFileExtensions: string[];
+    static getUserConfig(configPath: string): TDictionary;
+    static stringifyOptionAvailableValues(optionEnum: TDictionary): string;
+}

package/typings/src/cli/utils/IdentifierNamesCacheFileUtils.d.ts

@@ -0,0 +1,10 @@
+import { TIdentifierNamesCache } from '../../types/TIdentifierNamesCache';
+export declare class IdentifierNamesCacheFileUtils {
+    private static readonly identifierNamesCacheExtension;
+    private readonly identifierNamesCachePath;
+    constructor(identifierNamesCachePath: string | undefined);
+    private static isValidFilePath;
+    private static readFile;
+    readFile(): TIdentifierNamesCache | null;
+    writeFile(identifierNamesCache: TIdentifierNamesCache): void;
+}

package/typings/src/cli/utils/ObfuscatedCodeFileUtils.d.ts

@@ -0,0 +1,9 @@
+import { TInputCLIOptions } from '../../types/options/TInputCLIOptions';
+export declare class ObfuscatedCodeFileUtils {
+    private readonly inputPath;
+    private readonly options;
+    constructor(inputPath: string, options: TInputCLIOptions);
+    getOutputCodePath(filePath: string): string;
+    getOutputSourceMapPath(outputCodePath: string, sourceMapFileName?: string): string;
+    writeFile(outputPath: string, data: string): void;
+}

package/typings/src/cli/utils/SourceCodeFileUtils.d.ts

@@ -0,0 +1,15 @@
+import { TInputCLIOptions } from '../../types/options/TInputCLIOptions';
+import { IFileData } from '../../interfaces/cli/IFileData';
+export declare class SourceCodeFileUtils {
+    private readonly inputPath;
+    private readonly options;
+    constructor(inputPath: string, options: TInputCLIOptions);
+    private static isExcludedPath;
+    private static isDirectoryPath;
+    private static isFilePath;
+    private static isValidDirectory;
+    private static isValidFile;
+    private static readFile;
+    readSourceCode(): IFileData[];
+    private readDirectoryRecursive;
+}

package/typings/src/code-transformers/AbstractCodeTransformer.d.ts

@@ -0,0 +1,12 @@
+import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
+import { IOptions } from '../interfaces/options/IOptions';
+import { IRandomGenerator } from '../interfaces/utils/IRandomGenerator';
+import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../enums/code-transformers/CodeTransformationStage';
+export declare abstract class AbstractCodeTransformer implements ICodeTransformer {
+    readonly runAfter: CodeTransformer[] | undefined;
+    protected readonly options: IOptions;
+    protected readonly randomGenerator: IRandomGenerator;
+    protected constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    abstract transformCode(code: string, codeTransformationStage: CodeTransformationStage): string;
+}

package/{src/code-transformers/CodeTransformerNamesGroupsBuilder.ts → typings/src/code-transformers/CodeTransformerNamesGroupsBuilder.d.ts}

@@ -1,13 +1,5 @@
-import { injectable } from 'inversify';
-
 import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
-
 import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
-
 import { AbstractTransformerNamesGroupsBuilder } from '../utils/AbstractTransformerNamesGroupsBuilder';
-
-@injectable()
-export class CodeTransformerNamesGroupsBuilder extends AbstractTransformerNamesGroupsBuilder<
-    CodeTransformer,
-    ICodeTransformer
-> {}
+export declare class CodeTransformerNamesGroupsBuilder extends AbstractTransformerNamesGroupsBuilder<CodeTransformer, ICodeTransformer> {
+}

package/typings/src/code-transformers/CodeTransformersRunner.d.ts

@@ -0,0 +1,13 @@
+import { TCodeTransformerFactory } from '../types/container/code-transformers/TCodeTransformerFactory';
+import { ICodeTransformer } from '../interfaces/code-transformers/ICodeTransformer';
+import { ICodeTransformersRunner } from '../interfaces/code-transformers/ICodeTransformersRunner';
+import { ITransformerNamesGroupsBuilder } from '../interfaces/utils/ITransformerNamesGroupsBuilder';
+import { CodeTransformer } from '../enums/code-transformers/CodeTransformer';
+import { CodeTransformationStage } from '../enums/code-transformers/CodeTransformationStage';
+export declare class CodeTransformersRunner implements ICodeTransformersRunner {
+    private readonly codeTransformerFactory;
+    private readonly codeTransformerNamesGroupsBuilder;
+    constructor(codeTransformerFactory: TCodeTransformerFactory, codeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<CodeTransformer, ICodeTransformer>);
+    transform(code: string, codeTransformerNames: CodeTransformer[], codeTransformationStage: CodeTransformationStage): string;
+    private buildNormalizedCodeTransformers;
+}

package/typings/src/code-transformers/preparing-transformers/HashbangOperatorTransformer.d.ts

@@ -0,0 +1,11 @@
+import { IOptions } from '../../interfaces/options/IOptions';
+import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
+import { CodeTransformationStage } from '../../enums/code-transformers/CodeTransformationStage';
+import { AbstractCodeTransformer } from '../AbstractCodeTransformer';
+export declare class HashbangOperatorTransformer extends AbstractCodeTransformer {
+    private hashbangOperatorLine;
+    constructor(randomGenerator: IRandomGenerator, options: IOptions);
+    transformCode(code: string, codeTransformationStage: CodeTransformationStage): string;
+    private removeAndSaveHashbangOperatorLine;
+    private appendSavedHashbangOperatorLine;
+}

package/typings/src/constants/AlphabetString.d.ts

@@ -0,0 +1 @@
+export declare const alphabetString: string;

package/typings/src/constants/AlphabetStringUppercase.d.ts

@@ -0,0 +1 @@
+export declare const alphabetStringUppercase: string;

package/typings/src/constants/Base64Alphabet.d.ts

@@ -0,0 +1 @@
+export declare const base64alphabet: string;

package/typings/src/constants/Base64AlphabetSwapped.d.ts

@@ -0,0 +1 @@
+export declare const base64alphabetSwapped: string;

package/typings/src/constants/EcmaVersion.d.ts

@@ -0,0 +1 @@
+export declare const ecmaVersion: 10 | 3 | 5 | 6 | 7 | 8 | 9 | 11 | 12 | 13 | 2015 | 2016 | 2017 | 2018 | 2019 | 2020 | 2021 | 2022;

package/typings/src/constants/NumbersString.d.ts

@@ -0,0 +1 @@
+export declare const numbersString: string;

package/typings/src/container/InversifyContainerFacade.d.ts

@@ -0,0 +1,14 @@
+import { interfaces } from 'inversify';
+import { TInputOptions } from '../types/options/TInputOptions';
+import { IInversifyContainerFacade } from '../interfaces/container/IInversifyContainerFacade';
+export declare class InversifyContainerFacade implements IInversifyContainerFacade {
+    private readonly container;
+    constructor();
+    static getFactory<T extends string, U>(serviceIdentifier: interfaces.ServiceIdentifier<U>): (context: interfaces.Context) => (bindingName: T) => U;
+    static getCacheFactory<T extends string, U>(serviceIdentifier: interfaces.ServiceIdentifier<U>): (context: interfaces.Context) => (bindingName: T) => U;
+    static getConstructorFactory<T extends string, U>(serviceIdentifier: interfaces.ServiceIdentifier<interfaces.Newable<U>>, ...dependencies: interfaces.ServiceIdentifier<interfaces.Newable<Record<string, any>>>[]): (context: interfaces.Context) => (bindingName: T) => U;
+    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/container/ServiceIdentifiers.d.ts

@@ -0,0 +1,65 @@
+export declare enum ServiceIdentifiers {
+    Factory__ICalleeDataExtractor = "Factory<ICalleeDataExtractor>",
+    Factory__ICodeTransformer = "Factory<ICodeTransformer[]>",
+    Factory__IControlFlowCustomNode = "Factory<IControlFlowCustomNode>",
+    Factory__IControlFlowReplacer = "Factory<IControlFlowReplacer>",
+    Factory__ICustomCodeHelper = "Factory<ICustomCodeHelper>",
+    Factory__ICustomCodeHelperGroup = "Factory<ICustomCodeHelperGroup>",
+    Factory__IDeadCodeInjectionCustomNode = "Factory<IDeadCodeInjectionCustomNode>",
+    Factory__IIdentifierNamesGenerator = "Factory<IIdentifierNamesGenerator>",
+    Factory__INodeGuard = "Factory<INodeGuard>",
+    Factory__INodeTransformer = "Factory<INodeTransformer[]>",
+    Factory__IObfuscationResult = "Factory<IObfuscationResult>",
+    Factory__IObjectExpressionKeysTransformerCustomNode = "Factory<IObjectExpressionKeysTransformerCustomNode>",
+    Factory__IObjectExpressionExtractor = "Factory<IObjectExpressionExtractor>",
+    Factory__IStringArrayCustomNode = "Factory<IStringArrayCustomNode>",
+    Factory__IStringArrayIndexNode = "Factory<IStringArrayIndexNode>",
+    Factory__TControlFlowStorage = "Factory<TControlFlowStorage>",
+    IArrayUtils = "IArrayUtils",
+    ICalleeDataExtractor = "ICalleeDataExtractor",
+    ICallsGraphAnalyzer = "ICallsGraphAnalyzer",
+    ICodeTransformer = "ICodeTransformer",
+    ICodeTransformerNamesGroupsBuilder = "ICodeTransformerNamesGroupsBuilder",
+    ICodeTransformersRunner = "ICodeTransformersRunner",
+    ICryptUtils = "ICryptUtils",
+    ICryptUtilsStringArray = "ICryptUtilsStringArray",
+    ICustomCodeHelper = "ICustomCodeHelper",
+    ICustomCodeHelperGroup = "ICustomCodeHelperGroup",
+    IControlFlowReplacer = "IControlFlowReplacer",
+    ICustomCodeHelperFormatter = "ICustomCodeHelperFormatter",
+    ICustomCodeHelperObfuscator = "ICustomCodeHelperObfuscator",
+    IEscapeSequenceEncoder = "IEscapeSequenceEncoder",
+    IGlobalIdentifierNamesCacheStorage = "IGlobalIdentifierNamesCacheStorage",
+    IIdentifierNamesGenerator = "IIdentifierNamesGenerator",
+    IIdentifierReplacer = "IIdentifierReplacer",
+    IJavaScriptObfuscator = "IJavaScriptObfuscator",
+    ILevelledTopologicalSorter = "ILevelledTopologicalSorter",
+    ILiteralNodesCacheStorage = "ILiteralNodesCacheStorage",
+    ILogger = "ILogger",
+    INodeGuard = "INodeGuard",
+    INodeTransformer = "INodeTransformer",
+    INodeTransformerNamesGroupsBuilder = "INodeTransformerNamesGroupsBuilder",
+    INodeTransformersRunner = "INodeTransformersRunner",
+    INumberNumericalExpressionAnalyzer = "INumberNumericalExpressionAnalyzer",
+    IObfuscationResult = "IObfuscationResult",
+    IOptions = "IOptions",
+    IOptionsNormalizer = "IOptionsNormalizer",
+    IPrevailingKindOfVariablesAnalyzer = "IPrevailingKindOfVariablesAnalyzer",
+    IPropertyIdentifierNamesCacheStorage = "IPropertyIdentifierNamesCacheStorage",
+    IObjectExpressionExtractor = "IObjectExpressionExtractor",
+    IRandomGenerator = "IRandomGenerator",
+    IRenamePropertiesReplacer = "IRenamePropertiesReplacer",
+    IScopeIdentifiersTraverser = "IScopeIdentifiersTraverser",
+    ISourceCode = "ISourceCode",
+    IScopeAnalyzer = "IScopeAnalyzer",
+    IStringArrayIndexNode = "IStringArrayIndexNode",
+    IStringArrayScopeCallsWrappersDataStorage = "IStringArrayScopeCallsWrappersDataStorage",
+    IStringArrayStorage = "IStringArrayStorage",
+    IStringArrayStorageAnalyzer = "IStringArrayStorageAnalyzer",
+    IThroughIdentifierReplacer = "IThroughIdentifierReplacer",
+    IVisitedLexicalScopeNodesStackStorage = "IVisitedLexicalScopeNodesStackStorage",
+    Newable__ICustomNode = "Newable<ICustomNode>",
+    Newable__TControlFlowStorage = "Newable<TControlFlowStorage>",
+    TCustomNodeGroupStorage = "TCustomNodeGroupStorage",
+    TInputOptions = "TInputOptions"
+}

package/typings/src/container/modules/analyzers/AnalyzersModule.d.ts

@@ -0,0 +1,2 @@
+import { interfaces } from 'inversify';
+export declare const analyzersModule: interfaces.ContainerModule;