pyjsclear 0.1.0__py3-none-any.whl

pyjsclear/transforms/control_flow.py

@@ -0,0 +1,330 @@
+"""Control flow flattening recovery.
+
+Detects patterns like:
+  var _array = "1|0|3|2|4".split("|"), _index = 0;
+  while(true) { switch(_array[_index++]) { case "0": ...; continue; ... } break; }
+
+And reconstructs the linear statement sequence.
+"""
+
+from ..utils.ast_helpers import get_child_keys
+from ..utils.ast_helpers import is_identifier
+from ..utils.ast_helpers import is_literal
+from ..utils.ast_helpers import is_string_literal
+from .base import Transform
+
+
+class ControlFlowRecoverer(Transform):
+    """Recover control flow from flattened switch/loop dispatchers."""
+
+    rebuild_scope = True
+
+    def execute(self):
+        self._recover_in_bodies(self.ast)
+        return self.has_changed()
+
+    def _recover_in_bodies(self, root):
+        """Walk through the AST looking for bodies containing CFF patterns."""
+        stack = [root]
+        visited = set()
+        while stack:
+            node = stack.pop()
+            if not isinstance(node, dict) or 'type' not in node:
+                continue
+
+            node_id = id(node)
+            if node_id in visited:
+                continue
+            visited.add(node_id)
+
+            node_type = node.get('type', '')
+
+            # Check in body arrays
+            if node_type in ('Program', 'BlockStatement'):
+                self._try_recover_body(node, 'body', node.get('body', []))
+
+            # Queue children for processing
+            self._queue_children(node, stack)
+
+    @staticmethod
+    def _queue_children(node, stack):
+        """Add all child nodes to the traversal stack."""
+        for key in get_child_keys(node):
+            child = node.get(key)
+            if child is None:
+                continue
+            if isinstance(child, list):
+                for item in child:
+                    if isinstance(item, dict) and 'type' in item:
+                        stack.append(item)
+            elif isinstance(child, dict) and 'type' in child:
+                stack.append(child)
+
+    def _try_recover_body(self, parent_node, body_key, body):
+        """Try to find and recover CFF patterns in a body array."""
+        i = 0
+        while i < len(body):
+            statement = body[i]
+            if not isinstance(statement, dict):
+                i += 1
+                continue
+
+            if self._try_recover_variable_pattern(body, i, statement):
+                continue
+            if self._try_recover_expression_pattern(body, i, statement):
+                continue
+
+            i += 1
+
+    def _try_recover_variable_pattern(self, body, i, stmt):
+        """Try Pattern 1: VariableDeclaration with split + loop. Returns True if recovered."""
+        if stmt.get('type') != 'VariableDeclaration':
+            return False
+        state_info = self._find_state_array_in_decl(stmt)
+        if not state_info:
+            return False
+        states, state_var, counter_var = state_info
+        next_idx = i + 1
+        if next_idx >= len(body):
+            return False
+        recovered = self._try_recover_from_loop(body[next_idx], states, state_var, counter_var)
+        if recovered is None:
+            return False
+        body[i : next_idx + 1] = recovered
+        self.set_changed()
+        return True
+
+    def _try_recover_expression_pattern(self, body, i, stmt):
+        """Try Pattern 2: ExpressionStatement with split assignment + loop."""
+        if stmt.get('type') != 'ExpressionStatement':
+            return False
+        expr = stmt.get('expression')
+        if not expr or expr.get('type') != 'AssignmentExpression':
+            return False
+        state_info = self._find_state_from_assignment(expr)
+        if not state_info:
+            return False
+        states, state_var = state_info
+        next_idx = i + 1
+        counter_var = None
+        if next_idx < len(body):
+            counter_variable = self._find_counter_init(body[next_idx])
+            if counter_variable is not None:
+                counter_var = counter_variable
+                next_idx += 1
+        if next_idx >= len(body):
+            return False
+        recovered = self._try_recover_from_loop(body[next_idx], states, state_var, counter_var or '_index')
+        if recovered is None:
+            return False
+        body[i : next_idx + 1] = recovered
+        self.set_changed()
+        return True
+
+    def _find_state_array_in_decl(self, decl):
+        """Find "X".split("|") pattern in a VariableDeclaration."""
+        for declaration in decl.get('declarations', []):
+            initializer = declaration.get('init')
+            if not initializer or not self._is_split_call(initializer):
+                continue
+            states = self._extract_split_states(initializer)
+            if not states:
+                continue
+            if declaration.get('id', {}).get('type') != 'Identifier':
+                continue
+            state_var = declaration['id']['name']
+            counter_var = self._find_counter_in_declaration(decl, exclude=declaration)
+            return states, state_var, counter_var
+        return None
+
+    def _find_counter_in_declaration(self, decl, exclude):
+        """Find a numeric-initialized counter variable in a declaration, skipping *exclude*."""
+        for declaration in decl.get('declarations', []):
+            if declaration is exclude:
+                continue
+            if declaration.get('id', {}).get('type') != 'Identifier':
+                continue
+            initializer = declaration.get('init')
+            if (
+                initializer
+                and initializer.get('type') == 'Literal'
+                and isinstance(initializer.get('value'), (int, float))
+            ):
+                return declaration['id']['name']
+        return None
+
+    def _find_state_from_assignment(self, expr):
+        """Find state array from assignment expression."""
+        if expr.get('type') != 'AssignmentExpression':
+            return None
+        if not is_identifier(expr.get('left')):
+            return None
+        right = expr.get('right')
+        if self._is_split_call(right):
+            states = self._extract_split_states(right)
+            if states:
+                return states, expr['left']['name']
+        return None
+
+    def _find_counter_init(self, statement):
+        """Find counter variable initialization."""
+        if not isinstance(statement, dict):
+            return None
+        match statement.get('type'):
+            case 'VariableDeclaration':
+                for declaration in statement.get('declarations', []):
+                    if declaration.get('id', {}).get('type') == 'Identifier':
+                        initializer = declaration.get('init')
+                        if (
+                            initializer
+                            and initializer.get('type') == 'Literal'
+                            and isinstance(initializer.get('value'), (int, float))
+                        ):
+                            return declaration['id']['name']
+            case 'ExpressionStatement':
+                expr = statement.get('expression')
+                if (
+                    expr
+                    and expr.get('type') == 'AssignmentExpression'
+                    and is_identifier(expr.get('left'))
+                    and is_literal(expr.get('right'))
+                    and isinstance(expr['right'].get('value'), (int, float))
+                ):
+                    return expr['left']['name']
+        return None
+
+    def _is_split_call(self, node):
+        """Check if node is "X".split("|")."""
+        if not isinstance(node, dict):
+            return False
+        if node.get('type') != 'CallExpression':
+            return False
+        callee = node.get('callee')
+        if not callee or callee.get('type') != 'MemberExpression':
+            return False
+        object_expression = callee.get('object')
+        property_expression = callee.get('property')
+        if not is_string_literal(object_expression):
+            return False
+        if not (is_identifier(property_expression) and property_expression.get('name') == 'split') and not (
+            is_string_literal(property_expression) and property_expression.get('value') == 'split'
+        ):
+            return False
+        args = node.get('arguments', [])
+        if len(args) != 1 or not is_string_literal(args[0]):
+            return False
+        return True
+
+    def _extract_split_states(self, node):
+        """Extract states from "1|0|3|2|4".split("|")."""
+        callee = node['callee']
+        string = callee['object']['value']
+        separator = node['arguments'][0]['value']
+        return string.split(separator)
+
+    def _try_recover_from_loop(self, loop, states, state_var, counter_var):
+        """Try to recover statements from a for/while loop with switch dispatcher."""
+        if not isinstance(loop, dict):
+            return None
+
+        loop_type = loop.get('type', '')
+        switch_body = None
+        initial_value = 0
+
+        if loop_type == 'ForStatement':
+            # for(var _i = 0; ...) { switch(_array[_i++]) { ... } break; }
+            initial_value = self._extract_for_init_value(loop.get('init'))
+            switch_body = self._extract_switch_from_loop_body(loop.get('body'))
+
+        elif loop_type == 'WhileStatement':
+            test = loop.get('test')
+            if self._is_truthy(test):
+                switch_body = self._extract_switch_from_loop_body(loop.get('body'))
+
+        if switch_body is None:
+            return None
+
+        cases_map = self._build_case_map(switch_body.get('cases', []))
+        return self._reconstruct_statements(cases_map, states, initial_value)
+
+    @staticmethod
+    def _extract_for_init_value(initializer):
+        """Extract the initial counter value from a for-loop init clause."""
+        if not initializer:
+            return 0
+        if initializer.get('type') == 'VariableDeclaration':
+            for declaration in initializer.get('declarations', []):
+                if declaration.get('init') and declaration['init'].get('type') == 'Literal':
+                    return int(declaration['init'].get('value', 0))
+        elif initializer.get('type') == 'AssignmentExpression' and is_literal(initializer.get('right')):
+            return int(initializer['right'].get('value', 0))
+        return 0
+
+    @staticmethod
+    def _build_case_map(cases):
+        """Build map from case test value to (filtered statements, original statements)."""
+        cases_map = {}
+        for case in cases:
+            test = case.get('test')
+            if not (test and test.get('type') == 'Literal'):
+                continue
+            test_value = test['value']
+            if isinstance(test_value, float) and test_value == int(test_value):
+                key = str(int(test_value))
+            else:
+                key = str(test_value)
+            statements = [
+                statement
+                for statement in case.get('consequent', [])
+                if statement.get('type') not in ('ContinueStatement', 'BreakStatement')
+            ]
+            cases_map[key] = (statements, case.get('consequent', []))
+        return cases_map
+
+    @staticmethod
+    def _reconstruct_statements(cases_map, states, initial_value):
+        """Reconstruct linear statement sequence from case map and state order."""
+        recovered = []
+        for idx in range(initial_value, len(states)):
+            state = states[idx]
+            if state not in cases_map:
+                break
+            statements, original = cases_map[state]
+            recovered.extend(statements)
+            if original and original[-1].get('type') == 'ReturnStatement':
+                recovered.append(original[-1])
+                break
+        return recovered or None
+
+    def _extract_switch_from_loop_body(self, body):
+        """Extract SwitchStatement from loop body."""
+        if not isinstance(body, dict):
+            return None
+        if body.get('type') == 'BlockStatement':
+            stmts = body.get('body', [])
+            for stmt in stmts:
+                if stmt.get('type') == 'SwitchStatement':
+                    return stmt
+        elif body.get('type') == 'SwitchStatement':
+            return body
+        return None
+
+    def _is_truthy(self, node):
+        """Check if a test expression is always truthy."""
+        if not isinstance(node, dict):
+            return False
+        if node.get('type') == 'Literal':
+            return bool(node.get('value'))
+        # !0 = true, !![] = true
+        if node.get('type') == 'UnaryExpression' and node.get('operator') == '!':
+            arg = node.get('argument')
+            if arg and arg.get('type') == 'Literal' and arg.get('value') == 0:
+                return True
+            if arg and arg.get('type') == 'ArrayExpression':
+                return False  # ![] = false, but !![] = true
+            if arg and arg.get('type') == 'UnaryExpression' and arg.get('operator') == '!':
+                # !!something
+                inner = arg.get('argument')
+                if inner and inner.get('type') == 'ArrayExpression':
+                    return True
+        return False

pyjsclear/transforms/dead_branch.py

@@ -0,0 +1,71 @@
+"""Remove unreachable if/ternary branches based on literal tests."""
+
+from ..traverser import REMOVE
+from ..traverser import traverse
+from .base import Transform
+
+
+def _is_truthy_literal(node):
+    """Check if node is a literal that is truthy in JS. Returns None if unknown."""
+    if not isinstance(node, dict):
+        return None
+    match node.get('type', ''):
+        case 'Literal':
+            value = node.get('value')
+            if value is None:
+                return False  # null is falsy
+            match value:
+                case bool():
+                    return value
+                case int() | float():
+                    return value != 0
+                case str():
+                    return len(value) > 0
+                case _:
+                    return True
+        case 'UnaryExpression' if node.get('operator') == '!':
+            inner = _is_truthy_literal(node.get('argument'))
+            if inner is not None:
+                return not inner
+        case 'ArrayExpression' if len(node.get('elements', [])) == 0:
+            return True  # [] is truthy
+        case 'ObjectExpression' if len(node.get('properties', [])) == 0:
+            return True  # {} is truthy
+    return None
+
+
+def _unwrap_block(node):
+    """Unwrap a single-statement block to its contents."""
+    if isinstance(node, dict) and node.get('type') == 'BlockStatement':
+        body = node.get('body', [])
+        if len(body) == 1:
+            return body[0]
+    return node
+
+
+class DeadBranchRemover(Transform):
+    """Remove dead branches from if statements and ternary expressions."""
+
+    def execute(self):
+        def enter(node, parent, key, index):
+            node_type = node.get('type', '')
+
+            if node_type == 'IfStatement':
+                truthy = _is_truthy_literal(node.get('test'))
+                if truthy is None:
+                    return
+                self.set_changed()
+                if truthy:
+                    return node.get('consequent')
+                alt = node.get('alternate')
+                return alt if alt else REMOVE
+
+            if node_type == 'ConditionalExpression':
+                truthy = _is_truthy_literal(node.get('test'))
+                if truthy is None:
+                    return
+                self.set_changed()
+                return node.get('consequent' if truthy else 'alternate')
+
+        traverse(self.ast, {'enter': enter})
+        return self.has_changed()

pyjsclear/transforms/eval_unpack.py

@@ -0,0 +1,133 @@
+"""Eval/packer unpacker.
+
+Handles Dean Edwards packer (eval(function(p,a,c,k,e,d){...})) and
+generic eval(...) wrappers by replacing eval with identity capture.
+"""
+
+import os
+import re
+import shutil
+import subprocess
+import tempfile
+
+
+# Dean Edwards packer pattern
+_PACKER_RE = re.compile(
+    r"""eval\(function\(p,a,c,k,e,[dr]\)\{"""
+    r""".*?return p\}"""
+    r"""\('(.*?)',\s*(\d+)\s*,\s*(\d+)\s*,\s*'(.*?)'\s*\.split\('\|'\)""",
+    re.DOTALL,
+)
+
+# Simpler packer pattern (single-quoted packed string)
+_PACKER_RE2 = re.compile(
+    r"""eval\(function\s*\(p\s*,\s*a\s*,\s*c\s*,\s*k\s*,\s*e\s*,\s*[dr]\s*\)\s*\{"""
+    r"""[\s\S]*?return\s+p[\s\S]*?\}\s*\(\s*'((?:[^'\\]|\\.)*)'\s*,"""
+    r"""\s*(\d+)\s*,\s*(\d+)\s*,\s*'((?:[^'\\]|\\.)*)'\s*\.split\s*\(\s*'\|'\s*\)""",
+    re.DOTALL,
+)
+
+# Generic eval(...) pattern
+_EVAL_RE = re.compile(r'^eval\s*\(', re.MULTILINE)
+
+
+def is_eval_packed(code):
+    """Check if code uses eval packing."""
+    return bool(_PACKER_RE.search(code) or _PACKER_RE2.search(code) or _EVAL_RE.search(code.lstrip()))
+
+
+def _dean_edwards_unpack(packed, radix, count, keywords):
+    """Pure Python implementation of Dean Edwards unpacker."""
+
+    # Build the replacement function
+    def base_encode(c):
+        prefix = '' if c < radix else base_encode(int(c / radix))
+        c = c % radix
+        if c > 35:
+            return prefix + chr(c + 29)
+        return prefix + ('0123456789abcdefghijklmnopqrstuvwxyz'[c] if c < 36 else chr(c + 29))
+
+    # Build dictionary
+    lookup = {}
+    while count > 0:
+        count -= 1
+        key = base_encode(count)
+        lookup[key] = keywords[count] if count < len(keywords) and keywords[count] else key
+
+    # Replace tokens in packed string
+    def replacer(match):
+        token = match.group(0)
+        return lookup.get(token, token)
+
+    return re.sub(r'\b\w+\b', replacer, packed)
+
+
+def eval_unpack(code):
+    """Unpack eval-packed JavaScript. Returns unpacked code or None."""
+    # Try Dean Edwards packer first (pure Python)
+    result = _try_dean_edwards(code)
+    if result:
+        return result
+
+    # Try generic eval via Node.js
+    return _try_node_eval(code)
+
+
+def _try_dean_edwards(code):
+    """Try to unpack Dean Edwards packer format."""
+    for pattern in [_PACKER_RE, _PACKER_RE2]:
+        m = pattern.search(code)
+        if m:
+            packed = m.group(1)
+            radix = int(m.group(2))
+            count = int(m.group(3))
+            keywords_str = m.group(4)
+            keywords = keywords_str.split('|')
+
+            # Unescape the packed string
+            packed = packed.replace("\\'", "'").replace('\\\\', '\\')
+
+            try:
+                return _dean_edwards_unpack(packed, radix, count, keywords)
+            except Exception:
+                continue
+    return None
+
+
+def _try_node_eval(code):
+    """Try to unpack generic eval() by intercepting via Node.js."""
+    stripped = code.strip()
+    if not _EVAL_RE.search(stripped):
+        return None
+
+    node = shutil.which('node')
+    if not node:
+        return None
+
+    # Replace eval with a capture function
+    js_wrapper = (
+        'var _captured = null;\n'
+        'var _origEval = eval;\n'
+        'eval = function(x) { _captured = x; return x; };\n'
+        'try {\n' + stripped + '\n' + '} catch(e) {}\n'
+        'eval = _origEval;\n'
+        'if (_captured && typeof _captured === "string") console.log(_captured);\n'
+    )
+
+    try:
+        fd, tmp_path = tempfile.mkstemp(suffix='.js')
+        try:
+            with os.fdopen(fd, 'w') as f:
+                f.write(js_wrapper)
+            result = subprocess.run(
+                [node, tmp_path],
+                capture_output=True,
+                text=True,
+                timeout=5,
+            )
+            output = result.stdout.strip()
+            return output if output else None
+        finally:
+            os.unlink(tmp_path)
+    except (subprocess.TimeoutExpired, subprocess.SubprocessError, OSError):
+        return None