admin/javascript-obfuscator-javascript-obfuscator
1
0
Fork 0
mirror of https://github.com/javascript-obfuscator/javascript-obfuscator synced 2026-08-09 12:42:29 +00:00
Code Issues Packages Projects Releases Wiki Activity

Refactoring related to ArrayUtils, NodeMetadata and StringArray transformets

Browse Source
This commit is contained in:
sanex
2021-08-08 23:56:45 +03:00
parent a7e0f5885a
commit 061bffe2c4
13 changed files with 137 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/custom-nodes/string-array-nodes/AbstractStringArrayCallNode.ts
+2 -2
View File
@@ -105,7 +105,7 @@ export abstract class AbstractStringArrayCallNode extends AbstractCustomNode {
const stringArrayCallIndexNode: ESTree.Expression = this.stringArrayIndexNodeFactory(stringArrayIndexNodeName)
.getNode(normalizedIndex);
NodeMetadata.set(stringArrayCallIndexNode, { replacedLiteral: true });
NodeMetadata.set(stringArrayCallIndexNode, { stringArrayCallLiteralNode: true });
const hexadecimalNode: ESTree.Expression = isPositive
? stringArrayCallIndexNode
@@ -126,7 +126,7 @@ export abstract class AbstractStringArrayCallNode extends AbstractCustomNode {
protected getRc4KeyLiteralNode (decodeKey: string): ESTree.Literal {
const rc4KeyLiteralNode: ESTree.Literal = NodeFactory.literalNode(decodeKey);
NodeMetadata.set(rc4KeyLiteralNode, { replacedLiteral: true });
NodeMetadata.set(rc4KeyLiteralNode, { stringArrayCallLiteralNode: true });
return rc4KeyLiteralNode;
}
src/declarations/ESTree.d.ts
Vendored
+1 -1
View File
@@ -14,7 +14,7 @@ declare module 'estree' {
}
export interface LiteralNodeMetadata extends BaseNodeMetadata {
replacedLiteral?: boolean;
stringArrayCallLiteralNode?: boolean;
}
/**
src/interfaces/utils/IArrayUtils.ts
+7
View File
@@ -24,6 +24,13 @@ export interface IArrayUtils {
*/
getLastElement <T> (array: T[]): T | undefined;
/**
* @param {T[]} array
* @param {number} index
* @returns {T | undefined}
*/
getLastElementByIndex <T> (array: T[], index: number): T | undefined;
/**
* @param array
* @param times
src/node-transformers/converting-transformers/SplitStringTransformer.ts
+9 -16
View File
@@ -80,14 +80,14 @@ export class SplitStringTransformer extends AbstractNodeTransformer {
* @returns {IVisitor | null}
*/
public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
if (!this.options.splitStrings) {
return null;
}
switch (nodeTransformationStage) {
case NodeTransformationStage.Converting:
return {
enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
if (!this.options.splitStrings) {
return;
}
if (parentNode && NodeGuards.isLiteralNode(node)) {
return this.transformNode(node, parentNode);
}
@@ -115,7 +115,6 @@ export class SplitStringTransformer extends AbstractNodeTransformer {
// pass #1: split string on a large chunks with length of `firstPassChunkLength`
const firstPassChunksNode: ESTree.Node = this.transformLiteralNodeByChunkLength(
literalNode,
parentNode,
SplitStringTransformer.firstPassChunkLength
);
@@ -123,28 +122,28 @@ export class SplitStringTransformer extends AbstractNodeTransformer {
const secondPassChunksNode: ESTree.Node = estraverse.replace(firstPassChunksNode, {
// eslint-disable-next-line @typescript-eslint/no-shadow
enter: (node: ESTree.Node, parentNode: ESTree.Node | null) => {
if (parentNode && NodeGuards.isLiteralNode(node)) {
if (NodeGuards.isLiteralNode(node)) {
return this.transformLiteralNodeByChunkLength(
node,
parentNode,
this.options.splitStringsChunkLength
);
}
}
});
NodeUtils.parentizeNode(secondPassChunksNode, parentNode);
NodeUtils.parentizeAst(secondPassChunksNode);
return secondPassChunksNode;
}
/**
* @param {Literal} literalNode
* @param {Node} parentNode
* @param {number} chunkLength
* @returns {Node}
*/
private transformLiteralNodeByChunkLength (
literalNode: ESTree.Literal,
parentNode: ESTree.Node,
chunkLength: number
): ESTree.Node {
if (!NodeLiteralUtils.isStringLiteralNode(literalNode)) {
@@ -163,13 +162,7 @@ export class SplitStringTransformer extends AbstractNodeTransformer {
chunkLength
);
const binaryExpressionNode: ESTree.BinaryExpression =
this.transformStringChunksToBinaryExpressionNode(stringChunks);
NodeUtils.parentizeAst(binaryExpressionNode);
NodeUtils.parentizeNode(binaryExpressionNode, parentNode);
return binaryExpressionNode;
return this.transformStringChunksToBinaryExpressionNode(stringChunks);
}
/**
src/node-transformers/preparing-transformers/MetadataTransformer.ts
+1 -1
View File
@@ -65,7 +65,7 @@ export class MetadataTransformer extends AbstractNodeTransformer {
NodeMetadata.set(node, { ignoredNode: false });
if (NodeGuards.isLiteralNode(node)) {
NodeMetadata.set(node, { replacedLiteral: false });
NodeMetadata.set(node, { stringArrayCallLiteralNode: false });
}
return node;
src/node-transformers/rename-properties-transformers/RenamePropertiesTransformer.ts
+13 -12
View File
@@ -9,11 +9,12 @@ import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
import { RenamePropertiesMode } from '../../enums/node-transformers/rename-properties-transformers/RenamePropertiesMode';
import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
import { NodeGuards } from '../../node/NodeGuards';
import { NodeLiteralUtils } from '../../node/NodeLiteralUtils';
import { RenamePropertiesMode } from '../../enums/node-transformers/rename-properties-transformers/RenamePropertiesMode';
import { NodeUtils } from '../../node/NodeUtils';
@injectable()
export class RenamePropertiesTransformer extends AbstractNodeTransformer {
@@ -106,20 +107,20 @@ export class RenamePropertiesTransformer extends AbstractNodeTransformer {
* @returns {Node}
*/
public transformNode (node: ESTree.Node, parentNode: ESTree.Node): ESTree.Node {
let propertyNode: ESTree.Node | null = null;
if (NodeGuards.isPropertyNode(node)) {
return this.transformPropertyNode(node);
propertyNode = this.transformPropertyNode(node);
} else if (NodeGuards.isPropertyDefinitionNode(node)) {
propertyNode = this.transformPropertyDefinitionNode(node);
} else if (NodeGuards.isMemberExpressionNode(node)) {
propertyNode = this.transformMemberExpressionNode(node);
} else if (NodeGuards.isMethodDefinitionNode(node)) {
propertyNode = this.transformMethodDefinitionNode(node);
}
if (NodeGuards.isPropertyDefinitionNode(node)) {
return this.transformPropertyDefinitionNode(node);
}
if (NodeGuards.isMemberExpressionNode(node)) {
return this.transformMemberExpressionNode(node);
}
if (NodeGuards.isMethodDefinitionNode(node)) {
return this.transformMethodDefinitionNode(node);
if (propertyNode) {
NodeUtils.parentizeNode(propertyNode, parentNode);
}
return node;
src/node-transformers/string-array-transformers/StringArrayTransformer.ts
+15 -8
View File
@@ -139,7 +139,11 @@ export class StringArrayTransformer extends AbstractNodeTransformer {
this.prepareNode(node);
}
if (parentNode && NodeGuards.isLiteralNode(node) && !NodeMetadata.isReplacedLiteral(node)) {
if (
parentNode
&& NodeGuards.isLiteralNode(node)
&& !NodeMetadata.isStringArrayCallLiteralNode(node)
) {
return this.transformNode(node, parentNode);
}
}
@@ -187,16 +191,19 @@ export class StringArrayTransformer extends AbstractNodeTransformer {
const cacheKey: string = this.literalNodesCacheStorage.buildKey(literalValue, stringArrayStorageItemData);
const useCachedValue: boolean = this.literalNodesCacheStorage.shouldUseCachedValue(cacheKey, stringArrayStorageItemData);
let resultNode: ESTree.Node;
if (useCachedValue) {
return <ESTree.Node>this.literalNodesCacheStorage.get(cacheKey);
const nodeFromCache: ESTree.Node = <ESTree.Node>this.literalNodesCacheStorage.get(cacheKey);
resultNode = NodeUtils.clone(nodeFromCache);
} else {
resultNode = stringArrayStorageItemData
? this.getStringArrayCallNode(stringArrayStorageItemData)
: literalNode;
this.literalNodesCacheStorage.set(cacheKey, resultNode);
}
const resultNode: ESTree.Node = stringArrayStorageItemData
? this.getStringArrayCallNode(stringArrayStorageItemData)
: literalNode;
this.literalNodesCacheStorage.set(cacheKey, resultNode);
NodeUtils.parentizeNode(resultNode, parentNode);
return resultNode;
src/node/NodeFactory.ts
+1 -1
View File
@@ -63,7 +63,7 @@ export class NodeFactory {
public static binaryExpressionNode (
operator: ESTree.BinaryOperator,
left: ESTree.Expression,
right: ESTree.Expression,
right: ESTree.Expression
): ESTree.BinaryExpression {
return {
type: NodeType.BinaryExpression,
src/node/NodeMetadata.ts
+5 -2
View File
@@ -43,7 +43,10 @@ export class NodeMetadata {
* @param {Node} literalNode
* @returns {boolean}
*/
public static isReplacedLiteral (literalNode: ESTree.Literal): boolean {
return NodeMetadata.get<ESTree.LiteralNodeMetadata, 'replacedLiteral'>(literalNode, 'replacedLiteral') === true;
public static isStringArrayCallLiteralNode (literalNode: ESTree.Literal): boolean {
return NodeMetadata.get<
ESTree.LiteralNodeMetadata,
'stringArrayCallLiteralNode'
>(literalNode, 'stringArrayCallLiteralNode') === true;
}
}
src/storages/string-array-transformers/VisitedLexicalScopeNodesStackStorage.ts
+1 -3
View File
@@ -43,9 +43,7 @@ export class VisitedLexicalScopeNodesStackStorage extends ArrayStorage <TNodeWit
* @returns {TNodeWithLexicalScopeStatements | undefined}
*/
public getPenultimateElement (): TNodeWithLexicalScopeStatements | undefined {
const storageLength: number = this.getLength();
return this.get(storageLength - 2) ?? undefined;
return this.arrayUtils.getLastElementByIndex(this.getStorage(), 1);
}
/**
src/utils/ArrayUtils.ts
+10 -1
View File
@@ -85,9 +85,18 @@ export class ArrayUtils implements IArrayUtils {
* @returns {T | undefined}
*/
public getLastElement <T> (array: T[]): T | undefined {
return this.getLastElementByIndex(array, 0);
}
/**
* @param {T[]} array
* @param {number} index
* @returns {T | undefined}
*/
public getLastElementByIndex <T> (array: T[], index: number): T | undefined {
const arrayLength: number = array.length;
return array[arrayLength - 1] ?? undefined;
return array[arrayLength - 1 - index] ?? undefined;
}
/**