javascript-obfuscator 5.4.2 → 5.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "5.4.2",
+  "version": "5.4.4",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -35,7 +35,7 @@
     "eslint-scope": "8.4.0",
     "eslint-visitor-keys": "4.2.1",
     "fast-deep-equal": "3.1.3",
-    "inversify": "6.1.4",
+    "inversify": "7.11.0",
     "js-string-escape": "1.0.1",
     "md5": "2.3.0",
     "multimatch": "5.0.0",

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

@@ -6,10 +6,12 @@ export declare class ScopeAnalyzer implements IScopeAnalyzer {
     private static readonly sourceTypes;
     private static readonly emptyRangeValue;
     private scopeManager;
+    private sanitizedScopeManager;
     private static attachMissingRanges;
     private static isRootNode;
     analyze(astTree: ESTree.Node): void;
     acquireScope(node: ESTree.Node): eslintScope.Scope;
+    isAnalyzed(node: ESTree.Node): boolean;
     private fixAnnexBFunctionHoisting;
     private linkThroughReferences;
     private sanitizeScopes;

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

@@ -1,15 +1,15 @@
-import { interfaces } from 'inversify';
+import { ResolutionContext, ServiceIdentifier } from 'inversify';
 import { TConstructor } from '../types/TConstructor';
 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<TConstructor<Record<string, any>[], U>>, ...dependencies: interfaces.ServiceIdentifier<TConstructor<Record<string, any>[], U>>[]): (context: interfaces.Context) => (bindingName: T) => U;
-    get<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): T;
-    getNamed<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>, named: string | number | symbol): T;
+    static getFactory<T extends string, U>(serviceIdentifier: ServiceIdentifier<U>): (context: ResolutionContext) => (bindingName: T) => U;
+    static getCacheFactory<T extends string, U>(serviceIdentifier: ServiceIdentifier<U>): (context: ResolutionContext) => (bindingName: T) => U;
+    static getConstructorFactory<T extends string, U>(serviceIdentifier: ServiceIdentifier<TConstructor<Record<string, any>[], U>>, ...dependencies: ServiceIdentifier<TConstructor<Record<string, any>[], U>>[]): (context: ResolutionContext) => (bindingName: T) => U;
+    get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+    getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;
     load(sourceCode: string, sourceMap: string, options: TInputOptions): void;
     unload(): void;
 }

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

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

package/typings/src/container/modules/code-transformers/CodeTransformersModule.d.ts

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

package/typings/src/container/modules/custom-code-helpers/CustomCodeHelpersModule.d.ts

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

package/typings/src/container/modules/custom-nodes/CustomNodesModule.d.ts

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

package/typings/src/container/modules/generators/GeneratorsModule.d.ts

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

package/typings/src/container/modules/node/NodeModule.d.ts

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

package/typings/src/container/modules/node-transformers/ControlFlowTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/ConvertingTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/DeadCodeInjectionTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/FinalizingTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/InitializingTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/NodeTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/PreparingTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/RenameIdentifiersTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/RenamePropertiesTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/SimplifyingTransformersModule.d.ts

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

package/typings/src/container/modules/node-transformers/StringArrayTransformersModule.d.ts

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

package/typings/src/container/modules/options/OptionsModule.d.ts

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

package/typings/src/container/modules/storages/StoragesModule.d.ts

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

package/typings/src/container/modules/utils/UtilsModule.d.ts

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

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

@@ -4,4 +4,5 @@ import { IAnalyzer } from '../IAnalyzer';
 export interface IScopeAnalyzer extends IAnalyzer<[ESTree.Node], void> {
     analyze(astTree: ESTree.Node): void;
     acquireScope(node: ESTree.Node): eslintScope.Scope;
+    isAnalyzed(node: ESTree.Node): boolean;
 }

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

@@ -1,8 +1,8 @@
-import { interfaces } from 'inversify';
+import { ServiceIdentifier } 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;
+    get<T>(serviceIdentifier: ServiceIdentifier<T>): T;
+    getNamed<T>(serviceIdentifier: ServiceIdentifier<T>, named: string | number | symbol): T;
     load(sourceCode: string, sourceMap: string, options: TInputOptions): void;
     unload(): void;
 }

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

@@ -3,6 +3,6 @@ import { TScopeIdentifiersTraverserCallback } from '../../types/node/TScopeIdent
 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;
+    traverseScopeIdentifiers(programNode: ESTree.Program, callback: TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>, analyzeScope?: boolean): void;
+    traverseScopeThroughIdentifiers(node: ESTree.Node, callback: TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>, analyzeScope?: boolean): void;
 }

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

@@ -5,6 +5,7 @@ import { IVisitor } from './IVisitor';
 import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 export interface INodeTransformer extends ITransformer<NodeTransformer> {
+    runOnProgramNodeOnly?: boolean;
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
     prepareNode?(node: ESTree.Node, parentNode: ESTree.Node | null): void;
     restoreNode?(node: ESTree.Node, parentNode: ESTree.Node | null): void;

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

@@ -9,8 +9,9 @@ export declare class ScopeIdentifiersTraverser implements IScopeIdentifiersTrave
     private static readonly globalScopeNames;
     private readonly scopeAnalyzer;
     constructor(scopeAnalyzer: IScopeAnalyzer);
-    traverseScopeIdentifiers(programNode: ESTree.Program, parentNode: ESTree.Node | null, callback: TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>): void;
-    traverseScopeThroughIdentifiers(programNode: ESTree.Program, parentNode: ESTree.Node | null, callback: TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>): void;
+    traverseScopeIdentifiers(programNode: ESTree.Program, callback: TScopeIdentifiersTraverserCallback<IScopeIdentifiersTraverserCallbackData>, analyzeScope?: boolean): void;
+    traverseScopeThroughIdentifiers(programNode: ESTree.Program, callback: TScopeIdentifiersTraverserCallback<IScopeThroughIdentifiersTraverserCallbackData>, analyzeScope?: boolean): void;
     private traverseScopeIdentifiersRecursive;
     private traverseScopeThroughIdentifiersRecursive;
+    private acquireGlobalScope;
 }

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

@@ -8,6 +8,7 @@ import { NodeTransformer } from '../enums/node-transformers/NodeTransformer';
 import { NodeTransformationStage } from '../enums/node-transformers/NodeTransformationStage';
 export declare abstract class AbstractNodeTransformer implements INodeTransformer {
     readonly runAfter: NodeTransformer[] | undefined;
+    readonly runOnProgramNodeOnly: boolean | undefined;
     protected readonly options: IOptions;
     protected readonly randomGenerator: IRandomGenerator;
     constructor(randomGenerator: IRandomGenerator, options: IOptions);

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

@@ -10,6 +10,9 @@ export declare class NodeTransformersRunner implements INodeTransformersRunner {
     private readonly nodeTransformerNamesGroupsBuilder;
     constructor(nodeTransformerFactory: TNodeTransformerFactory, nodeTransformerNamesGroupsBuilder: ITransformerNamesGroupsBuilder<NodeTransformer, INodeTransformer>);
     transform<T extends ESTree.Node = ESTree.Program>(astTree: T, nodeTransformerNames: NodeTransformer[], nodeTransformationStage: NodeTransformationStage): T;
+    private buildVisitorsData;
+    private canRunOnProgramNodeOnly;
+    private runOnProgramNodeOnly;
     private buildNormalizedNodeTransformers;
     private mergeVisitorsForDirection;
 }

package/typings/src/node-transformers/dead-code-injection-transformers/DeadCodeInjectionIdentifiersTransformer.d.ts

@@ -11,7 +11,7 @@ export declare class DeadCodeInjectionIdentifiersTransformer extends AbstractNod
     private readonly scopeIdentifiersTraverser;
     constructor(identifierReplacer: IIdentifierReplacer, randomGenerator: IRandomGenerator, options: IOptions, scopeIdentifiersTraverser: IScopeIdentifiersTraverser);
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
-    transformNode(programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node;
+    transformNode(programNode: ESTree.Program): ESTree.Node;
     private transformScopeThroughIdentifiers;
     private storeIdentifierName;
     private replaceIdentifierName;

package/typings/src/node-transformers/preparing-transformers/VariablePreserveTransformer.d.ts

@@ -9,12 +9,14 @@ import { NodeTransformationStage } from '../../enums/node-transformers/NodeTrans
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 export declare class VariablePreserveTransformer extends AbstractNodeTransformer {
     readonly runAfter: NodeTransformer[];
+    readonly runOnProgramNodeOnly: boolean;
     private readonly identifierReplacer;
     private readonly scopeIdentifiersTraverser;
     constructor(identifierReplacer: IIdentifierReplacer, randomGenerator: IRandomGenerator, options: IOptions, scopeIdentifiersTraverser: IScopeIdentifiersTraverser);
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
-    transformNode(programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node;
+    transformNode(programNode: ESTree.Program): ESTree.Node;
     private preserveScopeVariableIdentifiers;
     private preserveIdentifierNameForRootLexicalScope;
     private preserveIdentifierNameForLexicalScope;
+    private shouldPreserveConvertingStageIdentifiers;
 }

package/typings/src/node-transformers/rename-identifiers-transformers/ScopeIdentifiersTransformer.d.ts

@@ -5,14 +5,17 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
 import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifiersTraverser';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 export declare class ScopeIdentifiersTransformer extends AbstractNodeTransformer {
+    readonly runAfter: NodeTransformer[];
+    readonly runOnProgramNodeOnly: boolean;
     private readonly identifierReplacer;
     private readonly lexicalScopesWithObjectPatternWithoutDeclarationMap;
     private readonly scopeIdentifiersTraverser;
     constructor(identifierReplacer: IIdentifierReplacer, randomGenerator: IRandomGenerator, options: IOptions, scopeIdentifiersTraverser: IScopeIdentifiersTraverser);
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
-    transformNode(programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node;
+    transformNode(programNode: ESTree.Program): ESTree.Node;
     private transformScopeVariableIdentifiers;
     private storeIdentifierName;
     private replaceIdentifierName;

package/typings/src/node-transformers/rename-identifiers-transformers/ScopeThroughIdentifiersTransformer.d.ts

@@ -7,13 +7,16 @@ import { IScopeIdentifiersTraverser } from '../../interfaces/node/IScopeIdentifi
 import { IThroughIdentifierReplacer } from '../../interfaces/node-transformers/rename-identifiers-transformers/replacer/IThroughIdentifierReplacer';
 import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
+import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 export declare class ScopeThroughIdentifiersTransformer extends AbstractNodeTransformer {
+    readonly runAfter: NodeTransformer[];
+    readonly runOnProgramNodeOnly: boolean;
     protected readonly scopeIdentifiersTraverser: IScopeIdentifiersTraverser;
     protected readonly throughIdentifierReplacer: IThroughIdentifierReplacer;
     constructor(throughIdentifierReplacer: IThroughIdentifierReplacer, scopeIdentifiersTraverser: IScopeIdentifiersTraverser, randomGenerator: IRandomGenerator, options: IOptions);
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
-    transformNode(programNode: ESTree.Program, parentNode: ESTree.Node): ESTree.Node;
+    transformNode(programNode: ESTree.Program): ESTree.Node;
     protected transformScopeThroughIdentifiers(reference: eslintScope.Reference, lexicalScopeNode: TNodeWithLexicalScope): void;
     protected replaceIdentifierName(reference: eslintScope.Reference): void;
 }