pyjsclear 0.1.4__tar.gz → 0.1.5__tar.gz

{pyjsclear-0.1.4/pyjsclear.egg-info → pyjsclear-0.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyjsclear
-Version: 0.1.4
+Version: 0.1.5
 Summary: Pure Python JavaScript deobfuscator
 Author-email: Intezer Labs <info@intezer.com>
 License-Expression: Apache-2.0
@@ -120,5 +120,6 @@ See [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md) and
 [NOTICE](NOTICE) for full attribution.
 
 Test samples include obfuscated JavaScript from the
-[JSIMPLIFIER dataset](https://zenodo.org/records/17531662) (GPL-3.0),
+[JSIMPLIFIER dataset](https://zenodo.org/records/17531662) (GPL-3.0)
+and the [Obfuscated JavaScript Dataset](https://www.kaggle.com/datasets/fanbyprinciple/obfuscated-javascript-dataset),
 used solely for evaluation purposes.

{pyjsclear-0.1.4 → pyjsclear-0.1.5}/README.md

@@ -94,5 +94,6 @@ See [THIRD_PARTY_LICENSES.md](THIRD_PARTY_LICENSES.md) and
 [NOTICE](NOTICE) for full attribution.
 
 Test samples include obfuscated JavaScript from the
-[JSIMPLIFIER dataset](https://zenodo.org/records/17531662) (GPL-3.0),
+[JSIMPLIFIER dataset](https://zenodo.org/records/17531662) (GPL-3.0)
+and the [Obfuscated JavaScript Dataset](https://www.kaggle.com/datasets/fanbyprinciple/obfuscated-javascript-dataset),
 used solely for evaluation purposes.

{pyjsclear-0.1.4 → pyjsclear-0.1.5}/pyjsclear/__init__.py

@@ -5,14 +5,18 @@ and javascript-deobfuscator (3 surface-cleanup modules) into a single
 Python package.
 """
 
+from pathlib import Path
+
 from .deobfuscator import Deobfuscator
 
 
-__version__ = '0.1.4'
+__all__ = ['Deobfuscator', 'deobfuscate', 'deobfuscate_file']
+
+__version__ = '0.1.5'
 
 
 def deobfuscate(code: str, max_iterations: int = 50) -> str:
-    """Deobfuscate JavaScript code. Returns cleaned source.
+    """Deobfuscate JavaScript code and return cleaned source.
 
     Args:
         code: JavaScript source code string.
@@ -24,7 +28,11 @@ def deobfuscate(code: str, max_iterations: int = 50) -> str:
     return Deobfuscator(code, max_iterations=max_iterations).execute()
 
 
-def deobfuscate_file(input_path: str, output_path: str | None = None, max_iterations: int = 50) -> str | bool:
+def deobfuscate_file(
+    input_path: str | Path,
+    output_path: str | Path | None = None,
+    max_iterations: int = 50,
+) -> str | bool:
     """Deobfuscate a JavaScript file.
 
     Args:
@@ -40,8 +48,9 @@ def deobfuscate_file(input_path: str, output_path: str | None = None, max_iterat
 
     result = deobfuscate(code, max_iterations=max_iterations)
 
-    if output_path:
-        with open(output_path, 'w') as output_file:
-            output_file.write(result)
-        return result != code
-    return result
+    if not output_path:
+        return result
+
+    with open(output_path, 'w') as output_file:
+        output_file.write(result)
+    return result != code

{pyjsclear-0.1.4 → pyjsclear-0.1.5}/pyjsclear/__main__.py

@@ -7,6 +7,7 @@ from . import deobfuscate
 
 
 def main() -> None:
+    """Parse CLI arguments and run the deobfuscator."""
     parser = argparse.ArgumentParser(description='Deobfuscate JavaScript files.')
     parser.add_argument('input', help='Input JS file (use - for stdin)')
     parser.add_argument('-o', '--output', help='Output file (default: stdout)')

pyjsclear-0.1.5/pyjsclear/deobfuscator.py

@@ -0,0 +1,391 @@
+"""Multi-pass deobfuscation orchestrator."""
+
+from __future__ import annotations
+
+from .generator import generate
+from .parser import parse
+from .scope import build_scope_tree
+from .transforms.aa_decode import aa_decode
+from .transforms.aa_decode import is_aa_encoded
+from .transforms.anti_tamper import AntiTamperRemover
+from .transforms.class_static_resolver import ClassStaticResolver
+from .transforms.class_string_decoder import ClassStringDecoder
+from .transforms.cleanup import EmptyIfRemover
+from .transforms.cleanup import LetToConst
+from .transforms.cleanup import OptionalCatchBinding
+from .transforms.cleanup import ReturnUndefinedCleanup
+from .transforms.cleanup import TrailingReturnRemover
+from .transforms.cleanup import VarToConst
+from .transforms.constant_prop import ConstantProp
+from .transforms.control_flow import ControlFlowRecoverer
+from .transforms.dead_branch import DeadBranchRemover
+from .transforms.dead_class_props import DeadClassPropRemover
+from .transforms.dead_expressions import DeadExpressionRemover
+from .transforms.dead_object_props import DeadObjectPropRemover
+from .transforms.else_if_flatten import ElseIfFlattener
+from .transforms.enum_resolver import EnumResolver
+from .transforms.eval_unpack import eval_unpack
+from .transforms.eval_unpack import is_eval_packed
+from .transforms.expression_simplifier import ExpressionSimplifier
+from .transforms.global_alias import GlobalAliasInliner
+from .transforms.hex_escapes import HexEscapes
+from .transforms.hex_escapes import decode_hex_escapes_source
+from .transforms.hex_numerics import HexNumerics
+from .transforms.jj_decode import is_jj_encoded
+from .transforms.jj_decode import jj_decode
+from .transforms.jsfuck_decode import is_jsfuck
+from .transforms.jsfuck_decode import jsfuck_decode
+from .transforms.logical_to_if import LogicalToIf
+from .transforms.member_chain_resolver import MemberChainResolver
+from .transforms.noop_calls import NoopCallRemover
+from .transforms.nullish_coalescing import NullishCoalescing
+from .transforms.object_packer import ObjectPacker
+from .transforms.object_simplifier import ObjectSimplifier
+from .transforms.optional_chaining import OptionalChaining
+from .transforms.property_simplifier import PropertySimplifier
+from .transforms.proxy_functions import ProxyFunctionInliner
+from .transforms.reassignment import ReassignmentRemover
+from .transforms.require_inliner import RequireInliner
+from .transforms.sequence_splitter import SequenceSplitter
+from .transforms.single_use_vars import SingleUseVarInliner
+from .transforms.string_revealer import StringRevealer
+from .transforms.unreachable_code import UnreachableCodeRemover
+from .transforms.unused_vars import UnusedVariableRemover
+from .transforms.variable_renamer import VariableRenamer
+from .transforms.xor_string_decode import XorStringDecoder
+from .utils.ast_helpers import _CHILD_KEYS
+from .utils.ast_helpers import get_child_keys
+
+
+_SCOPE_TRANSFORMS: frozenset[type] = frozenset(
+    {
+        ConstantProp,
+        SingleUseVarInliner,
+        ReassignmentRemover,
+        ProxyFunctionInliner,
+        UnusedVariableRemover,
+        ObjectSimplifier,
+        StringRevealer,
+        VariableRenamer,
+        VarToConst,
+        LetToConst,
+    }
+)
+
+# StringRevealer runs first to decode string arrays before other transforms
+# modify wrapper function structure. Remaining order follows obfuscator-io-deobfuscator.
+TRANSFORM_CLASSES: list[type] = [
+    StringRevealer,
+    HexEscapes,
+    HexNumerics,
+    ClassStringDecoder,
+    XorStringDecoder,
+    MemberChainResolver,
+    DeadClassPropRemover,
+    ClassStaticResolver,
+    EnumResolver,
+    RequireInliner,
+    GlobalAliasInliner,
+    UnusedVariableRemover,
+    ConstantProp,
+    ReassignmentRemover,
+    SingleUseVarInliner,
+    DeadBranchRemover,
+    UnreachableCodeRemover,
+    NoopCallRemover,
+    EmptyIfRemover,
+    DeadObjectPropRemover,
+    ObjectPacker,
+    ProxyFunctionInliner,
+    SequenceSplitter,
+    DeadExpressionRemover,
+    ExpressionSimplifier,
+    NullishCoalescing,
+    OptionalChaining,
+    LogicalToIf,
+    ElseIfFlattener,
+    OptionalCatchBinding,
+    ReturnUndefinedCleanup,
+    TrailingReturnRemover,
+    ControlFlowRecoverer,
+    PropertySimplifier,
+    AntiTamperRemover,
+    ObjectSimplifier,
+    StringRevealer,
+]
+
+_EXPENSIVE_TRANSFORMS: frozenset[type] = frozenset({ControlFlowRecoverer, ProxyFunctionInliner, ObjectPacker})
+
+_POST_PASS_TRANSFORMS: list[type] = [VariableRenamer, VarToConst, LetToConst]
+
+# File-size thresholds
+_LARGE_FILE_SIZE: int = 500_000  # 500 KB — reduce iterations
+_MAX_CODE_SIZE: int = 2_000_000  # 2 MB — use lite mode
+_LITE_MAX_ITERATIONS: int = 10
+_NODE_COUNT_LIMIT: int = 50_000  # skip ControlFlowRecoverer above this
+_VERY_LARGE_NODE_COUNT: int = 100_000  # cap iterations to 3
+
+
+def _count_nodes(syntax_tree: dict) -> int:
+    """Return the total number of nodes in *syntax_tree*.
+
+    Uses a direct iterative loop instead of simple_traverse to avoid
+    per-node callback overhead.
+    """
+    child_keys_map = _CHILD_KEYS
+    _get_child_keys = get_child_keys
+    _dict = dict
+    _list = list
+    _type = type
+
+    count = 0
+    stack = [syntax_tree]
+    while stack:
+        node = stack.pop()
+        node_type = node.get('type')
+        if node_type is None:
+            continue
+        count += 1
+        child_keys = child_keys_map.get(node_type)
+        if child_keys is None:
+            child_keys = _get_child_keys(node)
+        for key in child_keys:
+            child = node.get(key)
+            if child is None:
+                continue
+            if _type(child) is _list:
+                for item in child:
+                    if _type(item) is _dict and 'type' in item:
+                        stack.append(item)
+            elif _type(child) is _dict and 'type' in child:
+                stack.append(child)
+    return count
+
+
+class Deobfuscator:
+    """Multi-pass JavaScript deobfuscator.
+
+    Applies a configurable sequence of AST transforms in a loop until the code
+    stabilises or *max_iterations* is reached, then runs cosmetic post-passes.
+    """
+
+    _MAX_OUTER_CYCLES: int = 5
+
+    def __init__(self, code: str, max_iterations: int = 50) -> None:
+        self.original_code: str = code
+        self.max_iterations: int = max_iterations
+
+    def _run_pre_passes(self, code: str) -> str | None:
+        """Detect whole-file encodings (JSFuck, AAEncode, etc.) and decode them.
+
+        Returns the decoded source when a known encoding is found, or ``None``
+        to continue with the normal AST pipeline.
+        """
+        if is_jsfuck(code):
+            decoded = jsfuck_decode(code)
+            if decoded:
+                return decoded
+
+        if is_aa_encoded(code):
+            decoded = aa_decode(code)
+            if decoded:
+                return decoded
+
+        if is_jj_encoded(code):
+            decoded = jj_decode(code)
+            if decoded:
+                return decoded
+
+        if is_eval_packed(code):
+            decoded = eval_unpack(code)
+            if decoded:
+                return decoded
+
+        return None
+
+    def execute(self) -> str:
+        """Run all deobfuscation passes and return cleaned JavaScript source."""
+        code = self.original_code
+
+        decoded = self._run_pre_passes(code)
+        if decoded:
+            recursive_deobfuscator = Deobfuscator(decoded, max_iterations=self.max_iterations)
+            return recursive_deobfuscator.execute()
+
+        syntax_tree = self._try_parse_or_fallback(code)
+        if isinstance(syntax_tree, str):
+            return syntax_tree
+
+        return self._transform_loop(syntax_tree, code)
+
+    def _try_parse_or_fallback(self, code: str) -> dict | str:
+        """Parse *code* into an AST, falling back to hex-decode on failure.
+
+        Returns the parsed AST dict on success, or a decoded/original source
+        string when parsing fails.
+        """
+        try:
+            return parse(code)
+        except SyntaxError:
+            decoded = decode_hex_escapes_source(code)
+            if decoded != code:
+                return decoded
+            return self.original_code
+
+    def _transform_loop(self, syntax_tree: dict, code: str) -> str:
+        """Run the outer generate-reparse convergence loop and post-passes.
+
+        Returns the best deobfuscated source produced.
+        """
+        previous_code = code
+        last_changed_tree: dict | None = None
+
+        try:
+            for _cycle in range(self._MAX_OUTER_CYCLES):
+                changed = self._run_ast_transforms(
+                    syntax_tree,
+                    code_size=len(previous_code),
+                )
+
+                if not changed:
+                    break
+
+                last_changed_tree = syntax_tree
+                generated = self._try_generate(syntax_tree)
+                if generated is None or generated == previous_code:
+                    break
+
+                previous_code = generated
+                try:
+                    syntax_tree = parse(generated)
+                except SyntaxError:
+                    break
+
+            any_post_changed = self._run_post_passes(syntax_tree)
+
+            if last_changed_tree is None and not any_post_changed:
+                return self.original_code
+
+            return self._try_generate(syntax_tree) or previous_code
+        except RecursionError:
+            # Deeply nested JS can exceed Python's recursion limit during
+            # parsing or AST walking. Return best result so far.
+            return previous_code
+
+    @staticmethod
+    def _try_generate(syntax_tree: dict) -> str | None:
+        """Generate source from *syntax_tree*, returning ``None`` on failure."""
+        try:
+            return generate(syntax_tree)
+        except Exception:
+            return None
+
+    @staticmethod
+    def _run_post_passes(syntax_tree: dict) -> bool:
+        """Run cosmetic post-passes (renaming, var-to-const).
+
+        Returns ``True`` if any post-pass modified the AST.
+        """
+        any_changed = False
+        for post_transform_class in _POST_PASS_TRANSFORMS:
+            try:
+                if post_transform_class(syntax_tree).execute():
+                    any_changed = True
+            except Exception:
+                pass
+        return any_changed
+
+    def _run_ast_transforms(self, syntax_tree: dict, code_size: int = 0) -> bool:
+        """Run all AST transform passes.
+
+        Returns ``True`` if any transform modified the AST.
+        """
+        node_count = _count_nodes(syntax_tree) if code_size > _LARGE_FILE_SIZE else 0
+        iteration_limit = self._compute_iteration_limit(code_size, node_count)
+        active_transforms = self._select_transforms(code_size, node_count)
+
+        skipped_transforms: set[type] = set()
+
+        scope_tree: dict | None = None
+        node_scope: dict | None = None
+        scope_dirty: bool = True
+
+        any_transform_changed = False
+        for iteration in range(iteration_limit):
+            modified = False
+            for transform_class in active_transforms:
+                if transform_class in skipped_transforms:
+                    continue
+
+                result, scope_tree, node_scope, scope_dirty = self._execute_single_transform(
+                    syntax_tree,
+                    transform_class,
+                    scope_tree,
+                    node_scope,
+                    scope_dirty,
+                )
+
+                if result is None:
+                    continue
+                if result:
+                    modified = True
+                    any_transform_changed = True
+                elif iteration > 0:
+                    skipped_transforms.add(transform_class)
+
+            if not modified:
+                break
+
+        return any_transform_changed
+
+    def _compute_iteration_limit(self, code_size: int, node_count: int) -> int:
+        """Determine the maximum iteration count based on file/AST size."""
+        limit = self.max_iterations
+        if code_size > _LARGE_FILE_SIZE:
+            limit = min(limit, _LITE_MAX_ITERATIONS)
+        if node_count > _VERY_LARGE_NODE_COUNT:
+            limit = min(limit, 3)
+        return limit
+
+    @staticmethod
+    def _select_transforms(code_size: int, node_count: int) -> list[type]:
+        """Return the transform list, excluding expensive ones for large inputs."""
+        if code_size > _MAX_CODE_SIZE or node_count > _NODE_COUNT_LIMIT:
+            return [transform for transform in TRANSFORM_CLASSES if transform not in _EXPENSIVE_TRANSFORMS]
+        return TRANSFORM_CLASSES
+
+    @staticmethod
+    def _execute_single_transform(
+        syntax_tree: dict,
+        transform_class: type,
+        scope_tree: dict | None,
+        node_scope: dict | None,
+        scope_dirty: bool,
+    ) -> tuple[bool | None, dict | None, dict | None, bool]:
+        """Run a single transform, rebuilding scope lazily as needed.
+
+        Returns ``(result, scope_tree, node_scope, scope_dirty)`` where
+        *result* is ``True``/``False`` for success/no-change, or ``None``
+        if the transform raised an exception.
+        """
+        try:
+            if transform_class in _SCOPE_TRANSFORMS and scope_dirty:
+                scope_tree, node_scope = build_scope_tree(syntax_tree)
+                scope_dirty = False
+
+            if transform_class in _SCOPE_TRANSFORMS:
+                transform = transform_class(
+                    syntax_tree,
+                    scope_tree=scope_tree,
+                    node_scope=node_scope,
+                )
+            else:
+                transform = transform_class(syntax_tree)
+
+            result = transform.execute()
+        except Exception:
+            return None, scope_tree, node_scope, scope_dirty
+
+        if result:
+            scope_dirty = True
+        return result, scope_tree, node_scope, scope_dirty

{pyjsclear-0.1.4 → pyjsclear-0.1.5}/pyjsclear/generator.py

@@ -1,6 +1,8 @@
 """ESTree AST to JavaScript code generator."""
+
 from __future__ import annotations
 
+
 # Operator precedence (higher = binds tighter)
 _PRECEDENCE = {
     '=': 3,
@@ -72,9 +74,9 @@ def generate(node: dict | None, indent: int = 0) -> str:
         return str(node)
 
     node_type = node.get('type', '')
-    gen = _GENERATORS.get(node_type)
-    if gen:
-        return gen(node, indent)
+    generator_function = _GENERATORS.get(node_type)
+    if generator_function:
+        return generator_function(node, indent)
     return f'/* unknown: {node_type} */'
 
 
@@ -153,12 +155,12 @@ def _gen_function(node: dict, indent: int, is_expression: bool = False) -> str:
     name = generate(node['id'], indent) if node.get('id') else ''
     params = ', '.join(generate(param, indent) for param in node.get('params', []))
     async_prefix = 'async ' if node.get('async') else ''
-    gen_prefix = '*' if node.get('generator') else ''
+    generator_prefix = '*' if node.get('generator') else ''
     body = generate(node['body'], indent)
     if name:
-        return f'{async_prefix}function{gen_prefix} {name}({params}) {body}'
+        return f'{async_prefix}function{generator_prefix} {name}({params}) {body}'
     # Anonymous: always put space before parens (Babel style)
-    return f'{async_prefix}function{gen_prefix} ({params}) {body}'
+    return f'{async_prefix}function{generator_prefix} ({params}) {body}'
 
 
 def _gen_function_decl(node: dict, indent: int) -> str:
@@ -172,13 +174,13 @@ def _gen_function_expr(node: dict, indent: int) -> str:
 def _gen_arrow(node: dict, indent: int) -> str:
     params = node.get('params', [])
     async_prefix = 'async ' if node.get('async') else ''
-    param_str = '(' + ', '.join(generate(param, indent) for param in params) + ')'
+    parameter_string = '(' + ', '.join(generate(param, indent) for param in params) + ')'
     body = node.get('body', {})
-    body_str = generate(body, indent)
+    body_string = generate(body, indent)
     # Wrap object literal in parens to avoid ambiguity with block
     if body.get('type') == 'ObjectExpression':
-        body_str = '(' + body_str + ')'
-    return f'{async_prefix}{param_str} => {body_str}'
+        body_string = '(' + body_string + ')'
+    return f'{async_prefix}{parameter_string} => {body_string}'
 
 
 def _gen_return(node: dict, indent: int) -> str:
@@ -344,13 +346,13 @@ def _gen_assignment(node: dict, indent: int) -> str:
 
 def _gen_member(node: dict, indent: int) -> str:
     object_code = generate(node['object'], indent)
-    obj_type = node['object'].get('type', '')
+    object_type = node['object'].get('type', '')
     computed = node.get('computed')
 
     needs_parens = False
-    if obj_type == 'Literal' and isinstance(node['object'].get('value'), (int, float)):
+    if object_type == 'Literal' and isinstance(node['object'].get('value'), (int, float)):
         needs_parens = not computed
-    elif obj_type in (
+    elif object_type in (
         'BinaryExpression',
         'UnaryExpression',
         'ConditionalExpression',
@@ -364,12 +366,12 @@ def _gen_member(node: dict, indent: int) -> str:
         object_code = f'({object_code})'
 
     property_code = generate(node['property'], indent)
-    dot = '?.' if node.get('optional') else '.'
+    accessor = '?.' if node.get('optional') else '.'
     if computed:
         if node.get('optional'):
             return f'{object_code}?.[{property_code}]'
         return f'{object_code}[{property_code}]'
-    return f'{object_code}{dot}{property_code}'
+    return f'{object_code}{accessor}{property_code}'
 
 
 def _gen_call(node: dict, indent: int) -> str:
@@ -377,18 +379,18 @@ def _gen_call(node: dict, indent: int) -> str:
     callee_type = node['callee'].get('type', '')
     if callee_type in ('FunctionExpression', 'ArrowFunctionExpression', 'SequenceExpression'):
         callee = f'({callee})'
-    args = ', '.join(generate(argument, indent) for argument in node.get('arguments', []))
+    argument_string = ', '.join(generate(argument, indent) for argument in node.get('arguments', []))
     if node.get('optional'):
-        return f'{callee}?.({args})'
-    return f'{callee}({args})'
+        return f'{callee}?.({argument_string})'
+    return f'{callee}({argument_string})'
 
 
 def _gen_new(node: dict, indent: int) -> str:
     callee = generate(node['callee'], indent)
-    args = node.get('arguments', [])
-    if args:
-        arg_str = ', '.join(generate(argument, indent) for argument in args)
-        return f'new {callee}({arg_str})'
+    arguments = node.get('arguments', [])
+    if arguments:
+        argument_string = ', '.join(generate(argument, indent) for argument in arguments)
+        return f'new {callee}({argument_string})'
     return f'new {callee}()'
 
 
@@ -407,14 +409,13 @@ def _gen_conditional(node: dict, indent: int) -> str:
 
 
 def _gen_sequence(node: dict, indent: int) -> str:
-    exprs = ', '.join(generate(expression, indent) for expression in node.get('expressions', []))
-    return exprs
+    return ', '.join(generate(expression, indent) for expression in node.get('expressions', []))
 
 
 def _gen_bracket_list(elements: list, indent: int) -> str:
     """Generate a bracketed list of elements, replacing None with empty slots."""
-    elems = [generate(element, indent) if element is not None else '' for element in elements]
-    return '[' + ', '.join(elems) + ']'
+    generated_elements = [generate(element, indent) if element is not None else '' for element in elements]
+    return '[' + ', '.join(generated_elements) + ']'
 
 
 def _gen_array(node: dict, indent: int) -> str:
@@ -568,8 +569,8 @@ def _gen_method_def(node: dict, indent: int) -> str:
             return f'{static_prefix}set {key}({params}) {body}'
         case _:
             async_prefix = 'async ' if value.get('async') else ''
-            gen_prefix = '*' if value.get('generator') else ''
-            return f'{static_prefix}{async_prefix}{gen_prefix}{key}({params}) {body}'
+            generator_prefix = '*' if value.get('generator') else ''
+            return f'{static_prefix}{async_prefix}{generator_prefix}{key}({params}) {body}'
 
 
 def _gen_yield(node: dict, indent: int) -> str:
@@ -639,9 +640,9 @@ def _gen_import_declaration(node: dict, indent: int) -> str:
     specifiers = node.get('specifiers', [])
     if not specifiers:
         return f'import {source}'
-    default_specifiers = [s for s in specifiers if s.get('type') == 'ImportDefaultSpecifier']
-    namespace_specifiers = [s for s in specifiers if s.get('type') == 'ImportNamespaceSpecifier']
-    named_specifiers = [s for s in specifiers if s.get('type') == 'ImportSpecifier']
+    default_specifiers = [spec for spec in specifiers if spec.get('type') == 'ImportDefaultSpecifier']
+    namespace_specifiers = [spec for spec in specifiers if spec.get('type') == 'ImportNamespaceSpecifier']
+    named_specifiers = [spec for spec in specifiers if spec.get('type') == 'ImportSpecifier']
     parts = []
     if default_specifiers:
         parts.append(_gen_import_specifier(default_specifiers[0], indent))