javascript-obfuscator 2.18.1 → 3.0.1

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

@@ -1,302 +0,0 @@
-import { inject, injectable } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-
-import { TObjectExpressionExtractorFactory } from '../../types/container/node-transformers/TObjectExpressionExtractorFactory';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-import { ObjectExpressionExtractor } from '../../enums/node-transformers/converting-transformers/properties-extractors/ObjectExpressionExtractor';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeStatementUtils } from '../../node/NodeStatementUtils';
-
-@injectable()
-export class ObjectExpressionKeysTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {string}
-     */
-    private static readonly thisIdentifierName: string = 'this';
-
-    /**
-     * @type {ObjectExpressionExtractor[]}
-     */
-    private static readonly objectExpressionExtractorNames: ObjectExpressionExtractor[] = [
-        ObjectExpressionExtractor.ObjectExpressionToVariableDeclarationExtractor,
-        ObjectExpressionExtractor.BasePropertiesExtractor
-    ];
-
-    /**
-     * @type {TObjectExpressionExtractorFactory}
-     */
-    private readonly objectExpressionExtractorFactory: TObjectExpressionExtractorFactory;
-
-    /**
-     * @param {TObjectExpressionExtractorFactory} objectExpressionExtractorFactory
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.Factory__IObjectExpressionExtractor)
-            objectExpressionExtractorFactory: TObjectExpressionExtractorFactory,
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-
-        this.objectExpressionExtractorFactory = objectExpressionExtractorFactory;
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Node} objectExpressionParentNode
-     * @param {Statement} objectExpressionHostStatement
-     * @returns {boolean}
-     */
-    private static isProhibitedObjectExpressionNode (
-        objectExpressionNode: ESTree.ObjectExpression,
-        objectExpressionParentNode: ESTree.Node,
-        objectExpressionHostStatement: ESTree.Statement
-    ): boolean {
-        return ObjectExpressionKeysTransformer.isReferencedIdentifierName(
-                objectExpressionNode,
-                objectExpressionHostStatement
-            )
-            || ObjectExpressionKeysTransformer.isProhibitedArrowFunctionExpression(
-                objectExpressionNode,
-                objectExpressionParentNode
-            )
-            || ObjectExpressionKeysTransformer.isObjectExpressionWithCallExpression(
-                objectExpressionNode,
-            )
-            || ObjectExpressionKeysTransformer.isProhibitedSequenceExpression(
-                objectExpressionNode,
-                objectExpressionHostStatement
-            );
-    }
-
-    /**
-     * @param {Identifier | ThisExpression} node
-     * @returns {string}
-     */
-    private static getReferencedIdentifierName (node: ESTree.Identifier | ESTree.ThisExpression): string {
-        if (NodeGuards.isIdentifierNode(node)) {
-            return node.name;
-        } else {
-            return ObjectExpressionKeysTransformer.thisIdentifierName;
-        }
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Node} objectExpressionHostNode
-     * @returns {boolean}
-     */
-    private static isReferencedIdentifierName (
-        objectExpressionNode: ESTree.ObjectExpression,
-        objectExpressionHostNode: ESTree.Node,
-    ): boolean {
-        const identifierNamesSet: string[] = [];
-
-        let isReferencedIdentifierName: boolean = false;
-        let isCurrentNode: boolean = false;
-
-        // should mark node as prohibited if identifier of node is referenced somewhere inside other nodes
-        estraverse.traverse(objectExpressionHostNode, {
-            enter: (node: ESTree.Node): void | estraverse.VisitorOption => {
-                if (node === objectExpressionNode) {
-                    isCurrentNode = true;
-                }
-
-                if (!NodeGuards.isIdentifierNode(node) && !NodeGuards.isThisExpressionNode(node)) {
-                    return;
-                }
-
-                if (!isCurrentNode) {
-                    identifierNamesSet.push(ObjectExpressionKeysTransformer.getReferencedIdentifierName(node));
-
-                    return;
-                }
-
-                const hasReferencedIdentifierName: boolean = identifierNamesSet.includes(
-                    ObjectExpressionKeysTransformer.getReferencedIdentifierName(node)
-                );
-
-                if (hasReferencedIdentifierName) {
-                    isReferencedIdentifierName = true;
-                }
-            },
-            leave: (node: ESTree.Node): void | estraverse.VisitorOption => {
-                if (node === objectExpressionNode) {
-                    isCurrentNode = false;
-
-                    return estraverse.VisitorOption.Break;
-                }
-            }
-        });
-
-        return isReferencedIdentifierName;
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Node} objectExpressionNodeParentNode
-     * @returns {boolean}
-     */
-    private static isProhibitedArrowFunctionExpression (
-        objectExpressionNode: ESTree.ObjectExpression,
-        objectExpressionNodeParentNode: ESTree.Node
-    ): boolean {
-        return NodeGuards.isArrowFunctionExpressionNode(objectExpressionNodeParentNode)
-            && objectExpressionNodeParentNode.body === objectExpressionNode;
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @returns {boolean}
-     */
-    private static isObjectExpressionWithCallExpression (objectExpressionNode: ESTree.ObjectExpression): boolean {
-        let isCallExpressionLikeNodeFound: boolean = false;
-
-        estraverse.traverse(objectExpressionNode, {
-            enter: (node: ESTree.Node): void | estraverse.VisitorOption => {
-                const isCallExpressionLikeNode = NodeGuards.isCallExpressionNode(node)
-                    || NodeGuards.isNewExpressionNode(node);
-
-                if (!isCallExpressionLikeNode) {
-                    return;
-                }
-
-                isCallExpressionLikeNodeFound = true;
-
-                return estraverse.VisitorOption.Break;
-            }
-        });
-
-        return isCallExpressionLikeNodeFound;
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Node} objectExpressionHostNode
-     * @returns {boolean}
-     */
-    private static isProhibitedSequenceExpression (
-        objectExpressionNode: ESTree.ObjectExpression,
-        objectExpressionHostNode: ESTree.Node,
-    ): boolean {
-        return NodeGuards.isExpressionStatementNode(objectExpressionHostNode)
-            && NodeGuards.isSequenceExpressionNode(objectExpressionHostNode.expression)
-            && objectExpressionHostNode.expression.expressions.some((expressionNode: ESTree.Expression) =>
-                NodeGuards.isCallExpressionNode(expressionNode)
-                && NodeGuards.isSuperNode(expressionNode.callee)
-            );
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        if (!this.options.transformObjectKeys) {
-            return null;
-        }
-
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Converting:
-                return {
-                    leave: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (
-                            parentNode
-                            && NodeGuards.isObjectExpressionNode(node)
-                        ) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * replaces:
-     *     var object = {
-     *          foo: 1,
-     *          bar: 2
-     *     };
-     *
-     * on:
-     *     var _0xabc123 = {};
-     *     _0xabc123['foo'] = 1;
-     *     _0xabc123['bar'] = 2;
-     *     var object = _0xabc123;
-     *
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Node} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node {
-        if (!objectExpressionNode.properties.length) {
-            return objectExpressionNode;
-        }
-
-        const hostStatement: ESTree.Statement = NodeStatementUtils.getRootStatementOfNode(objectExpressionNode);
-
-        if (ObjectExpressionKeysTransformer.isProhibitedObjectExpressionNode(
-            objectExpressionNode,
-            parentNode,
-            hostStatement
-        )) {
-            return objectExpressionNode;
-        }
-
-        return this.applyObjectExpressionKeysExtractorsRecursive(
-            ObjectExpressionKeysTransformer.objectExpressionExtractorNames,
-            objectExpressionNode,
-            hostStatement
-        );
-    }
-
-    /**
-     * @param {ObjectExpressionExtractor[]} objectExpressionExtractorNames
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {Statement} hostStatement
-     * @returns {Node}
-     */
-    private applyObjectExpressionKeysExtractorsRecursive (
-        objectExpressionExtractorNames: ObjectExpressionExtractor[],
-        objectExpressionNode: ESTree.ObjectExpression,
-        hostStatement: ESTree.Statement
-    ): ESTree.Node {
-        const newObjectExpressionExtractorNames: ObjectExpressionExtractor[] = [...objectExpressionExtractorNames];
-        const objectExpressionExtractor: ObjectExpressionExtractor | undefined =
-            newObjectExpressionExtractorNames.shift();
-
-        if (!objectExpressionExtractor) {
-            return objectExpressionNode;
-        }
-
-        const {
-            nodeToReplace,
-            objectExpressionHostStatement: newObjectExpressionHostStatement,
-            objectExpressionNode: newObjectExpressionNode
-        } = this.objectExpressionExtractorFactory(objectExpressionExtractor)
-            .extract(objectExpressionNode, hostStatement);
-
-        this.applyObjectExpressionKeysExtractorsRecursive(
-            newObjectExpressionExtractorNames,
-            newObjectExpressionNode,
-            newObjectExpressionHostStatement
-        );
-
-        return nodeToReplace;
-    }
-}

package/src/node-transformers/converting-transformers/ObjectExpressionTransformer.ts

@@ -1,107 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeGuards } from '../../node/NodeGuards';
-
-/**
- * replaces:
- *     var object = { PSEUDO: 1 };
- *
- * on:
- *     var object = { 'PSEUDO': 1 };
- */
-@injectable()
-export class ObjectExpressionTransformer extends AbstractNodeTransformer {
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Converting:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isObjectExpressionNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * @param {ObjectExpression} objectExpressionNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (objectExpressionNode: ESTree.ObjectExpression, parentNode: ESTree.Node): ESTree.Node {
-        objectExpressionNode.properties
-            .forEach((property: ESTree.Property | ESTree.SpreadElement) => {
-                if (!NodeGuards.isPropertyNode(property)) {
-                    return;
-                }
-
-                if (!property.key) {
-                    return;
-                }
-
-                if (property.computed) {
-                    this.transformComputedProperty(property);
-                } else {
-                    this.transformBaseProperty(property);
-                }
-            });
-
-        return objectExpressionNode;
-    }
-
-    /**
-     * @param {Property} property
-     */
-    private transformComputedProperty (property: ESTree.Property): void {
-        if (!NodeGuards.isLiteralNode(property.key) || !(typeof property.key.value === 'string')) {
-            return;
-        }
-
-        property.key = NodeFactory.literalNode(property.key.value);
-    }
-
-    /**
-     * @param {Property} property
-     */
-    private transformBaseProperty (property: ESTree.Property): void {
-        if (property.shorthand) {
-            property.shorthand = false;
-        }
-
-        if (!NodeGuards.isIdentifierNode(property.key)) {
-            return;
-        }
-
-        property.key = NodeFactory.literalNode(property.key.name);
-    }
-}

package/src/node-transformers/converting-transformers/ObjectPatternPropertiesTransformer.ts

@@ -1,84 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as ESTree from 'estree';
-
-import { TNodeWithLexicalScope } from '../../types/node/TNodeWithLexicalScope';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeLexicalScopeUtils } from '../../node/NodeLexicalScopeUtils';
-import { NodeUtils } from '../../node/NodeUtils';
-
-@injectable()
-export class ObjectPatternPropertiesTransformer extends AbstractNodeTransformer {
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | null {
-        switch (nodeTransformationStage) {
-            case NodeTransformationStage.Converting:
-                return {
-                    enter: (node: ESTree.Node, parentNode: ESTree.Node | null): ESTree.Node | undefined => {
-                        if (parentNode && NodeGuards.isPropertyNode(node)) {
-                            return this.transformNode(node, parentNode);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * replaces:
-     *     const {foo} = bar;
-     *
-     * on:
-     *     const {foo: foo} = bar;
-     *
-     * @param {Property} propertyNode
-     * @param {NodeGuards} parentNode
-     * @returns {NodeGuards}
-     */
-    public transformNode (propertyNode: ESTree.Property, parentNode: ESTree.Node): ESTree.Node {
-        if (!NodeGuards.isObjectPatternNode(parentNode) || !propertyNode.shorthand) {
-            return propertyNode;
-        }
-
-        if (!this.options.renameGlobals) {
-            const lexicalScope: TNodeWithLexicalScope | undefined = NodeLexicalScopeUtils.getLexicalScope(propertyNode);
-            const shouldNotTransformGlobalPropertyNode: boolean = !!lexicalScope && NodeGuards.isProgramNode(lexicalScope);
-
-            if (shouldNotTransformGlobalPropertyNode) {
-                return propertyNode;
-            }
-        }
-
-        propertyNode.shorthand = false;
-        propertyNode.value = NodeUtils.clone(propertyNode.value);
-
-        NodeUtils.parentizeNode(propertyNode.value, propertyNode);
-
-        return propertyNode;
-    }
-}

package/src/node-transformers/converting-transformers/SplitStringTransformer.ts

@@ -1,206 +0,0 @@
-import { inject, injectable, } from 'inversify';
-import { ServiceIdentifiers } from '../../container/ServiceIdentifiers';
-
-import * as estraverse from '@javascript-obfuscator/estraverse';
-import * as ESTree from 'estree';
-import * as stringz from 'stringz';
-
-import { IOptions } from '../../interfaces/options/IOptions';
-import { IRandomGenerator } from '../../interfaces/utils/IRandomGenerator';
-import { IVisitor } from '../../interfaces/node-transformers/IVisitor';
-
-import { NodeTransformer } from '../../enums/node-transformers/NodeTransformer';
-import { NodeTransformationStage } from '../../enums/node-transformers/NodeTransformationStage';
-
-import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
-import { NodeFactory } from '../../node/NodeFactory';
-import { NodeGuards } from '../../node/NodeGuards';
-import { NodeLiteralUtils } from '../../node/NodeLiteralUtils';
-import { NodeUtils } from '../../node/NodeUtils';
-
-/**
- * Splits strings into parts
- */
-@injectable()
-export class SplitStringTransformer extends AbstractNodeTransformer {
-    /**
-     * @type {number}
-     */
-    private static readonly firstPassChunkLength: number = 1000;
-
-    /**
-     * @type {NodeTransformer[]}
-     */
-    public override runAfter: NodeTransformer[] = [
-        NodeTransformer.ObjectExpressionKeysTransformer,
-        NodeTransformer.TemplateLiteralTransformer
-    ];
-
-    /**
-     * @param {IRandomGenerator} randomGenerator
-     * @param {IOptions} options
-     */
-    public constructor (
-        @inject(ServiceIdentifiers.IRandomGenerator) randomGenerator: IRandomGenerator,
-        @inject(ServiceIdentifiers.IOptions) options: IOptions
-    ) {
-        super(randomGenerator, options);
-    }
-
-    /**
-     * @param {string} string
-     * @param {number} stringLength
-     * @param {number} chunkSize
-     * @returns {string[]}
-     */
-    private static chunkString (
-        string: string,
-        stringLength: number,
-        chunkSize: number
-    ): string[] {
-        const chunksCount: number = Math.ceil(stringLength / chunkSize);
-        const chunks: string[] = [];
-
-        let nextChunkStartIndex: number = 0;
-
-        for (
-            let chunkIndex: number = 0;
-            chunkIndex < chunksCount;
-            ++chunkIndex, nextChunkStartIndex += chunkSize
-        ) {
-            // eslint-disable-next-line unicorn/prefer-string-slice
-            chunks[chunkIndex] = stringz.substr(string, nextChunkStartIndex, chunkSize);
-        }
-
-        return chunks;
-    }
-
-    /**
-     * @param {NodeTransformationStage} nodeTransformationStage
-     * @returns {IVisitor | null}
-     */
-    public getVisitor (nodeTransformationStage: NodeTransformationStage): IVisitor | 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);
-                        }
-                    }
-                };
-
-            default:
-                return null;
-        }
-    }
-
-    /**
-     * Needs to split string on chunks of length `splitStringsChunkLength` in two pass, because of
-     * `Maximum call stack size exceeded` error in `esrecurse` package
-     *
-     * @param {Literal} literalNode
-     * @param {Node} parentNode
-     * @returns {Node}
-     */
-    public transformNode (literalNode: ESTree.Literal, parentNode: ESTree.Node): ESTree.Node {
-        if (NodeLiteralUtils.isProhibitedLiteralNode(literalNode, parentNode)) {
-            return literalNode;
-        }
-
-        // pass #1: split string on a large chunks with length of `firstPassChunkLength`
-        const firstPassChunksNode: ESTree.Node = this.transformLiteralNodeByChunkLength(
-            literalNode,
-            parentNode,
-            SplitStringTransformer.firstPassChunkLength
-        );
-
-        // pass #2: split large chunks on a chunks with length of `splitStringsChunkLength`
-        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)) {
-                    return this.transformLiteralNodeByChunkLength(
-                        node,
-                        parentNode,
-                        this.options.splitStringsChunkLength
-                    );
-                }
-            }
-        });
-
-        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)) {
-            return literalNode;
-        }
-
-        const valueLength: number = stringz.length(literalNode.value);
-
-        if (chunkLength >= valueLength) {
-            return literalNode;
-        }
-
-        const stringChunks: string[] = SplitStringTransformer.chunkString(
-            literalNode.value,
-            valueLength,
-            chunkLength
-        );
-
-        const binaryExpressionNode: ESTree.BinaryExpression =
-            this.transformStringChunksToBinaryExpressionNode(stringChunks);
-
-        NodeUtils.parentizeAst(binaryExpressionNode);
-        NodeUtils.parentizeNode(binaryExpressionNode, parentNode);
-
-        return binaryExpressionNode;
-    }
-
-    /**
-     * @param {string[]} chunks
-     * @returns {BinaryExpression}
-     */
-    private transformStringChunksToBinaryExpressionNode (chunks: string[]): ESTree.BinaryExpression {
-        const firstChunk: string | undefined = chunks.shift();
-        const secondChunk: string | undefined = chunks.shift();
-
-        if (!firstChunk || !secondChunk) {
-            throw new Error('First and second chunks values should not be empty');
-        }
-
-        const initialBinaryExpressionNode: ESTree.BinaryExpression = NodeFactory.binaryExpressionNode(
-            '+',
-            NodeFactory.literalNode(firstChunk),
-            NodeFactory.literalNode(secondChunk)
-        );
-
-        return chunks.reduce<ESTree.BinaryExpression>(
-            (binaryExpressionNode: ESTree.BinaryExpression, chunk: string) => {
-                const chunkLiteralNode: ESTree.Literal = NodeFactory.literalNode(chunk);
-
-                return NodeFactory.binaryExpressionNode(
-                    '+',
-                    binaryExpressionNode,
-                    chunkLiteralNode
-                );
-            },
-            initialBinaryExpressionNode
-        );
-    }
-}