javascript-obfuscator 5.1.0 → 5.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "javascript-obfuscator",
-  "version": "5.1.0",
+  "version": "5.2.1",
   "description": "JavaScript obfuscator",
   "keywords": [
     "obfuscator",
@@ -129,12 +129,9 @@
     "prepare": "husky install"
   },
   "author": {
-    "name": "Timofey Kachalov"
+    "name": "Timofei Kachalov"
   },
-  "contributors": [
-    "Timofey Kachalov (https://github.com/sanex3339)",
-    "Dmitry Zamotkin (https://github.com/zamotkin)"
-  ],
+  "contributors": ["Timofei Kachalov (https://github.com/sanex3339)", "Dmitry Zamotkin (https://github.com/zamotkin)"],
   "license": "BSD-2-Clause",
   "packageManager": "yarn@1.22.21+sha512.ca75da26c00327d26267ce33536e5790f18ebd53266796fbb664d2a4a5116308042dd8ee7003b276a20eace7d3c5561c3577bdd71bcb67071187af124779620a"
 }

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

@@ -10,5 +10,8 @@ export declare class ScopeAnalyzer implements IScopeAnalyzer {
     private static isRootNode;
     analyze(astTree: ESTree.Node): void;
     acquireScope(node: ESTree.Node): eslintScope.Scope;
+    private fixAnnexBFunctionHoisting;
+    private linkThroughReferences;
     private sanitizeScopes;
+    private walkScopes;
 }

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

@@ -4,5 +4,6 @@ export declare enum ObfuscatingGuard {
     ForceTransformStringObfuscatingGuard = "ForceTransformStringObfuscatingGuard",
     IgnoredImportObfuscatingGuard = "IgnoredImportObfuscatingGuard",
     ImportMetaObfuscationGuard = "ImportMetaObfuscationGuard",
+    ProcessEnvObfuscationGuard = "ProcessEnvObfuscationGuard",
     ReservedStringObfuscatingGuard = "ReservedStringObfuscatingGuard"
 }

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/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/control-flow-transformers/control-flow-replacers/LogicalExpressionControlFlowReplacer.d.ts

@@ -10,4 +10,5 @@ export declare class LogicalExpressionControlFlowReplacer extends ExpressionWith
     constructor(controlFlowCustomNodeFactory: TControlFlowCustomNodeFactory, identifierNamesGeneratorFactory: TIdentifierNamesGeneratorFactory, randomGenerator: IRandomGenerator, options: IOptions);
     replace(logicalExpressionNode: ESTree.LogicalExpression, parentNode: ESTree.Node, controlFlowStorage: IControlFlowStorage): ESTree.Node;
     private checkForProhibitedExpressions;
+    private expressionContainsProhibitedNodes;
 }

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

@@ -5,7 +5,7 @@ import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
 import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
 import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 export declare class ClassFieldTransformer extends AbstractNodeTransformer {
-    private static readonly ignoredNames;
+    private static readonly ignoredName;
     constructor(randomGenerator: IRandomGenerator, options: IOptions);
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
     transformNode(classFieldNode: ESTree.MethodDefinition | ESTree.PropertyDefinition, parentNode: ESTree.Node): ESTree.Node;

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

@@ -10,11 +10,10 @@ export declare class ObjectExpressionKeysTransformer extends AbstractNodeTransfo
     private static readonly objectExpressionExtractorNames;
     private readonly objectExpressionExtractorFactory;
     constructor(objectExpressionExtractorFactory: TObjectExpressionExtractorFactory, randomGenerator: IRandomGenerator, options: IOptions);
+    private static checkProhibitedPatterns;
     private static isProhibitedObjectExpressionNode;
-    private static getReferencedIdentifierName;
-    private static isReferencedIdentifierName;
+    private static isProhibitedLoopBody;
     private static isProhibitedArrowFunctionExpression;
-    private static isObjectExpressionWithCallExpression;
     private static isProhibitedSequenceExpression;
     getVisitor(nodeTransformationStage: NodeTransformationStage): IVisitor | null;
     transformNode(objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node;

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

@@ -0,0 +1,8 @@
+import * as ESTree from 'estree';
+import { IObfuscatingGuard } from '../../../interfaces/node-transformers/preparing-transformers/obfuscating-guards/IObfuscatingGuard';
+import { ObfuscatingGuardResult } from '../../../enums/node/ObfuscatingGuardResult';
+export declare class ProcessEnvObfuscationGuard implements IObfuscatingGuard {
+    private static isProcessEnvMemberExpression;
+    private static isPartOfProcessEnvChain;
+    check(node: ESTree.Node): ObfuscatingGuardResult;
+}

package/typings/src/utils/EscapeSequenceEncoder.d.ts

@@ -2,6 +2,7 @@ import { IEscapeSequenceEncoder } from '../interfaces/utils/IEscapeSequenceEncod
 export declare class EscapeSequenceEncoder implements IEscapeSequenceEncoder {
     private static readonly ASCIICharactersRegExp;
     private static readonly forceEscapeCharactersRegExp;
+    private static readonly replaceRegExp;
     private readonly stringsCache;
     encode(string: string, encodeAllSymbols: boolean): string;
 }

package/dist/index.browser.js.LICENSE.txt

@@ -1,45 +0,0 @@
-/*!
- * Determine if an object is a Buffer
- *
- * @author   Feross Aboukhadijeh <https://feross.org>
- * @license  MIT
- */
-
-/*!
-Copyright (C) 2016-2024 Timofey Kachalov <sanex3339@yandex.ru>
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-  * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-  * Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/*! *****************************************************************************
-Copyright (C) Microsoft. All rights reserved.
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use
-this file except in compliance with the License. You may obtain a copy of the
-License at http://www.apache.org/licenses/LICENSE-2.0
-
-THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
-WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
-MERCHANTABLITY OR NON-INFRINGEMENT.
-
-See the Apache Version 2.0 License for specific language governing permissions
-and limitations under the License.
-***************************************************************************** */

package/dist/index.cli.js.LICENSE.txt

@@ -1,23 +0,0 @@
-/*!
-Copyright (C) 2016-2024 Timofey Kachalov <sanex3339@yandex.ru>
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-  * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-  * Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/

package/dist/index.js.LICENSE.txt

@@ -1,23 +0,0 @@
-/*!
-Copyright (C) 2016-2024 Timofey Kachalov <sanex3339@yandex.ru>
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-  * Redistributions of source code must retain the above copyright
-    notice, this list of conditions and the following disclaimer.
-  * Redistributions in binary form must reproduce the above copyright
-    notice, this list of conditions and the following disclaimer in the
-    documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/