javascript-obfuscator 5.2.0 → 5.3.0-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "5.2.0",
+  "version": "5.3.0-beta.0",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -23,6 +23,7 @@
   "dependencies": {
     "@javascript-obfuscator/escodegen": "2.3.1",
     "@javascript-obfuscator/estraverse": "5.4.0",
+    "@vercel/blob": ">=0.23.0",
     "acorn": "8.15.0",
     "assert": "2.1.0",
     "chalk": "4.1.2",

package/typings/src/JavaScriptObfuscatorCLIFacade.d.ts

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

package/typings/src/JavaScriptObfuscatorFacade.d.ts

@@ -14,4 +14,4 @@ declare class JavaScriptObfuscatorFacade {
 }
 export { JavaScriptObfuscatorFacade as JavaScriptObfuscator };
 export { ApiError } from './pro-api/ApiError';
-export type { IProApiConfig, TProApiProgressCallback } from './interfaces/pro-api/IProApiClient';
+export type { IProApiConfig, IProObfuscationResult, TProApiProgressCallback } from './interfaces/pro-api/IProApiClient';

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

@@ -15,11 +15,12 @@ export declare class JavaScriptObfuscatorCLI implements IInitializable {
     private static buildOptions;
     private static filterOptions;
     initialize(): void;
-    run(): void;
+    run(): Promise<void>;
     private configureCommands;
     private configureHelp;
     private processSourceCodeData;
     private processSourceCode;
+    private processSourceCodeWithProApi;
     private processSourceCodeWithoutSourceMap;
     private processSourceCodeWithSourceMap;
 }

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

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

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

@@ -7,14 +7,17 @@ export declare abstract class AbstractIdentifierNamesGenerator implements IIdent
     protected readonly randomGenerator: IRandomGenerator;
     protected readonly preservedNamesSet: Set<string>;
     protected readonly lexicalScopesPreservedNamesMap: WeakMap<TNodeWithLexicalScope, Set<string>>;
+    protected readonly allLexicalScopePreservedNames: 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;
+    isValidIdentifierNameInAllScopes(name: string): boolean;
     private isReservedName;
     abstract generateForGlobalScope(nameLength?: number): string;
+    abstract generateForGlobalScopeWithAllScopesValidation(nameLength?: number): string;
     abstract generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
     abstract generateForLabel(label: string, nameLength?: number): string;
     abstract generateNext(nameLength?: number): string;

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

@@ -11,8 +11,10 @@ export declare class DictionaryIdentifierNamesGenerator extends AbstractIdentifi
     private static incrementIdentifierName;
     generateNext(): string;
     generateForGlobalScope(): string;
+    generateForGlobalScopeWithAllScopesValidation(): string;
     generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope): string;
     generateForLabel(label: string): string;
+    private generateForGlobalScopeInternal;
     private generateNewDictionaryName;
     private getInitialIdentifierNames;
     private getIncrementedIdentifierNames;

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

@@ -7,6 +7,9 @@ export declare class HexadecimalIdentifierNamesGenerator extends AbstractIdentif
     constructor(randomGenerator: IRandomGenerator, options: IOptions);
     generateNext(nameLength?: number): string;
     generateForGlobalScope(nameLength?: number): string;
+    generateForGlobalScopeWithAllScopesValidation(nameLength?: number): string;
     generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
     generateForLabel(label: string, nameLength?: number): string;
+    private generateForGlobalScopeInternal;
+    private generateNextName;
 }

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

@@ -15,6 +15,7 @@ export declare class MangledIdentifierNamesGenerator extends AbstractIdentifierN
     constructor(randomGenerator: IRandomGenerator, options: IOptions, setUtils: ISetUtils);
     generateNext(nameLength?: number): string;
     generateForGlobalScope(nameLength?: number): string;
+    generateForGlobalScopeWithAllScopesValidation(nameLength?: number): string;
     generateForLexicalScope(lexicalScopeNode: TNodeWithLexicalScope, nameLength?: number): string;
     generateForLabel(label: string, nameLength?: number): string;
     isIncrementedMangledName(nextName: string, prevName: string): boolean;
@@ -23,6 +24,7 @@ export declare class MangledIdentifierNamesGenerator extends AbstractIdentifierN
     protected updatePreviousMangledName(name: string): void;
     protected updatePreviousMangledNameForLabel(name: string, label: string, lastMangledNameForLabel: string): void;
     protected generateNewMangledName(previousMangledName: string, validationFunction?: (newIdentifierName: string) => boolean): string;
+    private generateForGlobalScopeInternal;
     private getLastMangledNameForScopes;
     private getLastMangledNameForLabel;
 }

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

@@ -7,6 +7,8 @@ export interface IIdentifierNamesGenerator {
     generateNext(nameLength?: number): string;
     isValidIdentifierName(identifierName: string): boolean;
     isValidIdentifierNameInLexicalScopes(identifierName: string, lexicalScopeNodes: TNodeWithLexicalScope[]): boolean;
+    isValidIdentifierNameInAllScopes(identifierName: string): boolean;
+    generateForGlobalScopeWithAllScopesValidation(nameLength?: number): string;
     preserveName(identifierName: string): void;
     preserveNameForLexicalScope(identifierName: string, lexicalScope: TNodeWithLexicalScope): void;
 }

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

@@ -4,5 +4,7 @@ export interface ICLIOptions extends IOptions {
     readonly exclude: string[];
     readonly identifierNamesCachePath: string;
     readonly output: string;
+    readonly proApiToken: string;
+    readonly proApiVersion: string;
     readonly version: string;
 }

package/typings/src/interfaces/pro-api/IProApiClient.d.ts

@@ -21,3 +21,7 @@ export interface IProApiStreamMessage {
     index?: number;
     total?: number;
 }
+export interface IProApiBlobUploadResponse {
+    blobUrl?: string;
+    error?: string;
+}

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

@@ -45,6 +45,7 @@ export declare class NodeGuards {
     static isLabeledStatementNode(node: ESTree.Node): node is ESTree.LabeledStatement;
     static isLiteralNode(node: ESTree.Node): node is ESTree.Literal;
     static isLogicalExpressionNode(node: ESTree.Node): node is ESTree.LogicalExpression;
+    static isLoopStatementNode(node: ESTree.Node): node is ESTree.ForStatement | ESTree.ForInStatement | ESTree.ForOfStatement | ESTree.WhileStatement | ESTree.DoWhileStatement;
     static isMemberExpressionNode(node: ESTree.Node): node is ESTree.MemberExpression;
     static isMetaPropertyNode(node: ESTree.Node): node is ESTree.MetaProperty;
     static isMethodDefinitionNode(node: ESTree.Node): node is ESTree.MethodDefinition;

package/typings/src/node-transformers/converting-transformers/ObjectExpressionKeysTransformer.d.ts

@@ -12,6 +12,7 @@ export declare class ObjectExpressionKeysTransformer extends AbstractNodeTransfo
     constructor(objectExpressionExtractorFactory: TObjectExpressionExtractorFactory, randomGenerator: IRandomGenerator, options: IOptions);
     private static checkProhibitedPatterns;
     private static isProhibitedObjectExpressionNode;
+    private static isProhibitedLoopBody;
     private static isProhibitedArrowFunctionExpression;
     private static isProhibitedSequenceExpression;
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;

package/typings/src/pro-api/ProApiClient.d.ts

@@ -1,9 +1,20 @@
 import { TInputOptions } from '../types/options/TInputOptions';
 import { IProApiConfig, IProObfuscationResult, TProApiProgressCallback } from '../interfaces/pro-api/IProApiClient';
 export declare class ProApiClient {
+    private static readonly apiHost;
+    private static readonly apiUrl;
+    private static readonly uploadTokenUrl;
+    private static readonly defaultTimeout;
+    private static readonly blobUploadThreshold;
     private readonly config;
     constructor(config: IProApiConfig);
+    static hasProFeatures(options: TInputOptions): boolean;
     obfuscate(sourceCode: string, options?: TInputOptions, onProgress?: TProApiProgressCallback): Promise<IProObfuscationResult>;
+    private obfuscateDirect;
+    private obfuscateWithBlobUpload;
+    private uploadToBlob;
+    private getUploadToken;
+    private uploadWithClientToken;
     private handleStreamingResponse;
     private reassembleChunkedResponse;
 }

package/typings/src/pro-api/enums/VMBytecodeFormat.d.ts

@@ -0,0 +1,4 @@
+export declare const VMBytecodeFormat: Readonly<{
+    Json: 'json';
+    Binary: 'binary';
+}>;

package/typings/src/pro-api/enums/VMTargetFunctionsMode.d.ts

@@ -0,0 +1,4 @@
+export declare const VMTargetFunctionsMode: Readonly<{
+    Root: 'root';
+    Comment: 'comment';
+}>;