crates/core/src/rules/un_es6_class.rs

GitHub
use std::collections::HashSet;

use swc_core::atoms::Atom;
use swc_core::common::util::take::Take;
use swc_core::common::{Mark, Span, SyntaxContext, DUMMY_SP};
use swc_core::ecma::ast::{
    ArrowExpr, AssignExpr, AssignOp, AssignTarget, BindingIdent, BlockStmt, BlockStmtOrExpr,
    CallExpr, Callee, Class, ClassDecl, ClassMember, ClassMethod, ClassProp, ComputedPropName,
    Constructor, Decl, ExportDecl, Expr, ExprOrSpread, ExprStmt, FnExpr, Function, Ident,
    IdentName, ImportSpecifier, Lit, MemberExpr, MemberProp, MethodKind, ModuleDecl,
    ModuleExportName, ModuleItem, Param, ParamOrTsParamProp, Pat, PropName, SeqExpr,
    SimpleAssignTarget, Stmt, VarDecl,
};
use swc_core::ecma::visit::{VisitMut, VisitMutWith, VisitWith};

use super::expr_utils::is_unresolved_ident;
use super::helper_matcher::{binding_key, BindingKey};
use super::transpiler_helper_utils::{
    detect_helper_from_path, is_call_super_fn, is_inherits_fn, is_set_prototype_of_fn,
    is_tslib_path, is_tslib_require_expr_with_mark, tslib_member_ts_helper_kind,
    tslib_require_ts_helper_kind_with_mark, LocalHelperContext, TranspilerHelperKind, TsHelperKind,
};
use super::RewriteLevel;
use crate::utils::paren::strip_parens;

pub struct UnEs6Class {
    unresolved_mark: Mark,
    rewrite_level: RewriteLevel,
    module_helper_context: Option<Es6ClassHelperContext>,
}

impl UnEs6Class {
    pub fn new(unresolved_mark: Mark) -> Self {
        Self::new_with_level(unresolved_mark, RewriteLevel::Standard)
    }

    pub fn new_with_level(unresolved_mark: Mark, rewrite_level: RewriteLevel) -> Self {
        Self {
            unresolved_mark,
            rewrite_level,
            module_helper_context: None,
        }
    }

    pub(crate) fn run_with_helpers(
        module: &mut swc_core::ecma::ast::Module,
        unresolved_mark: Mark,
        rewrite_level: RewriteLevel,
        local_helpers: &LocalHelperContext,
    ) {
        let mut rule = Self::new_with_level(unresolved_mark, rewrite_level);
        rule.module_helper_context = Some(Es6ClassHelperContext::from_local_helpers(
            &module.body,
            unresolved_mark,
            local_helpers,
        ));
        module.visit_mut_with(&mut rule);
    }
}

impl VisitMut for UnEs6Class {
    fn visit_mut_module_items(&mut self, items: &mut Vec<ModuleItem>) {
        // Pipeline path: use pre-built context from LocalHelperContext.
        // Standalone path (unit tests): full body-shape scan.
        let helper_context = self.module_helper_context.take().unwrap_or_else(|| {
            Es6ClassHelperContext::from_module_items(items, self.unresolved_mark)
        });
        let mut inner =
            UnEs6ClassInner::new(helper_context, self.unresolved_mark, self.rewrite_level);
        items.visit_mut_with(&mut inner);
    }

    fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
        // Non-module context: scan local scope for helpers
        let helper_context = Es6ClassHelperContext::from_stmts(stmts, self.unresolved_mark);
        let mut inner =
            UnEs6ClassInner::new(helper_context, self.unresolved_mark, self.rewrite_level);
        stmts.visit_mut_with(&mut inner);
    }
}

#[derive(Clone)]
struct Es6ClassHelperContext {
    inherits_helpers: HashSet<BindingKey>,
    ts_extends_helpers: HashSet<BindingKey>,
    tslib_namespaces: HashSet<BindingKey>,
    set_prototype_of_helpers: HashSet<BindingKey>,
    create_class_helpers: HashSet<BindingKey>,
    call_super_helpers: HashSet<BindingKey>,
}

impl Es6ClassHelperContext {
    fn from_local_helpers(
        items: &[ModuleItem],
        unresolved_mark: Mark,
        local_helpers: &LocalHelperContext,
    ) -> Self {
        let ts_extends_helpers = local_helpers.ts_helpers_of_kind(TsHelperKind::Extends);
        let mut inherits_helpers: HashSet<BindingKey> = local_helpers
            .helpers_of_kind(TranspilerHelperKind::Inherits)
            .into_keys()
            .collect();
        inherits_helpers.extend(ts_extends_helpers.iter().cloned());
        inherits_helpers.extend(collect_inherits_helpers_from_items(items));
        let mut call_super_helpers: HashSet<BindingKey> = local_helpers
            .helpers_of_kind(TranspilerHelperKind::CallSuper)
            .into_keys()
            .collect();
        call_super_helpers.extend(collect_call_super_helpers_from_items(items));
        let mut create_class_helpers: HashSet<BindingKey> = local_helpers
            .helpers_of_kind(TranspilerHelperKind::CreateClass)
            .into_keys()
            .collect();
        create_class_helpers.extend(collect_create_class_helpers_from_items(
            items,
            unresolved_mark,
        ));
        Self {
            inherits_helpers,
            ts_extends_helpers,
            tslib_namespaces: local_helpers.tslib_namespaces().clone(),
            set_prototype_of_helpers: collect_set_prototype_of_helpers_from_items(items),
            create_class_helpers,
            call_super_helpers,
        }
    }

    fn from_module_items(items: &[ModuleItem], unresolved_mark: Mark) -> Self {
        let tslib_namespaces = collect_tslib_namespaces_from_items(items, unresolved_mark);
        let mut ts_extends_helpers = collect_ts_extends_helpers_from_items(items);
        ts_extends_helpers.extend(collect_tslib_extends_helpers_from_items(
            items,
            &tslib_namespaces,
            unresolved_mark,
        ));
        let mut inherits_helpers = collect_inherits_helpers_from_items(items);
        inherits_helpers.extend(ts_extends_helpers.iter().cloned());

        Self {
            inherits_helpers,
            ts_extends_helpers,
            tslib_namespaces,
            set_prototype_of_helpers: collect_set_prototype_of_helpers_from_items(items),
            create_class_helpers: collect_create_class_helpers_from_items(items, unresolved_mark),
            call_super_helpers: collect_call_super_helpers_from_items(items),
        }
    }

    fn from_stmts(stmts: &[Stmt], unresolved_mark: Mark) -> Self {
        let ts_extends_helpers = collect_ts_extends_helpers_from_stmts(stmts);
        let tslib_namespaces = collect_tslib_namespaces_from_stmts(stmts, unresolved_mark);
        let mut inherits_helpers = collect_inherits_helpers_from_stmts(stmts);
        inherits_helpers.extend(ts_extends_helpers.iter().cloned());
        inherits_helpers.extend(collect_tslib_extends_helpers_from_stmts(
            stmts,
            &tslib_namespaces,
            unresolved_mark,
        ));

        Self {
            inherits_helpers,
            ts_extends_helpers,
            tslib_namespaces,
            set_prototype_of_helpers: collect_set_prototype_of_helpers_from_stmts(stmts),
            create_class_helpers: collect_create_class_helpers_from_stmts(stmts, unresolved_mark),
            call_super_helpers: collect_call_super_helpers_from_stmts(stmts),
        }
    }

    fn extend(&mut self, other: &Self) {
        self.inherits_helpers
            .extend(other.inherits_helpers.iter().cloned());
        self.ts_extends_helpers
            .extend(other.ts_extends_helpers.iter().cloned());
        self.tslib_namespaces
            .extend(other.tslib_namespaces.iter().cloned());
        self.set_prototype_of_helpers
            .extend(other.set_prototype_of_helpers.iter().cloned());
        self.create_class_helpers
            .extend(other.create_class_helpers.iter().cloned());
        self.call_super_helpers
            .extend(other.call_super_helpers.iter().cloned());
    }
}

/// Inner visitor that carries helper name sets through all scopes.
struct UnEs6ClassInner {
    helpers: Es6ClassHelperContext,
    unresolved_mark: Mark,
    rewrite_level: RewriteLevel,
}

impl UnEs6ClassInner {
    fn new(
        helper_context: Es6ClassHelperContext,
        unresolved_mark: Mark,
        rewrite_level: RewriteLevel,
    ) -> Self {
        Self {
            helpers: helper_context,
            unresolved_mark,
            rewrite_level,
        }
    }
}

impl VisitMut for UnEs6ClassInner {
    fn visit_mut_stmts(&mut self, stmts: &mut Vec<Stmt>) {
        let mut scope_helpers = Es6ClassHelperContext::from_stmts(stmts, self.unresolved_mark);
        scope_helpers.extend(&self.helpers);
        let mut scoped_inner =
            UnEs6ClassInner::new(scope_helpers, self.unresolved_mark, self.rewrite_level);
        stmts.visit_mut_children_with(&mut scoped_inner);

        let mut converted_any = false;
        let old = std::mem::take(stmts);
        for stmt in old {
            match stmt {
                Stmt::Decl(Decl::Var(ref var_decl)) => {
                    if let Some(class_decl) = try_iife_to_class(
                        var_decl,
                        &scoped_inner.helpers.inherits_helpers,
                        &scoped_inner.helpers.tslib_namespaces,
                        &scoped_inner.helpers.create_class_helpers,
                        &scoped_inner.helpers.call_super_helpers,
                        self.unresolved_mark,
                        self.rewrite_level,
                        var_decl.span,
                    ) {
                        stmts.push(Stmt::Decl(Decl::Class(class_decl)));
                        converted_any = true;
                    } else {
                        stmts.push(stmt);
                    }
                }
                other => stmts.push(other),
            }
        }
        if converted_any {
            remove_orphaned_create_class_helpers(
                stmts,
                &scoped_inner.helpers.create_class_helpers,
                self.unresolved_mark,
            );
            remove_orphaned_ts_extends_helpers_stmts(
                stmts,
                &scoped_inner.helpers.ts_extends_helpers,
            );
            remove_orphaned_fn_helpers_stmts(stmts, &scoped_inner.helpers.inherits_helpers);
            remove_orphaned_fn_helpers_stmts(stmts, &scoped_inner.helpers.set_prototype_of_helpers);
            remove_orphaned_fn_helpers_stmts(stmts, &scoped_inner.helpers.call_super_helpers);
        }
    }

    fn visit_mut_module_items(&mut self, items: &mut Vec<ModuleItem>) {
        items.visit_mut_children_with(self);

        let mut converted_any = false;
        let old = std::mem::take(items);
        for item in old {
            match item {
                ModuleItem::Stmt(Stmt::Decl(Decl::Var(ref var_decl))) => {
                    if let Some(class_decl) = try_iife_to_class(
                        var_decl,
                        &self.helpers.inherits_helpers,
                        &self.helpers.tslib_namespaces,
                        &self.helpers.create_class_helpers,
                        &self.helpers.call_super_helpers,
                        self.unresolved_mark,
                        self.rewrite_level,
                        var_decl.span,
                    ) {
                        items.push(ModuleItem::Stmt(Stmt::Decl(Decl::Class(class_decl))));
                        converted_any = true;
                    } else {
                        items.push(item);
                    }
                }
                ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
                    span: export_span,
                    decl: Decl::Var(ref var_decl),
                })) => {
                    if let Some(class_decl) = try_iife_to_class(
                        var_decl,
                        &self.helpers.inherits_helpers,
                        &self.helpers.tslib_namespaces,
                        &self.helpers.create_class_helpers,
                        &self.helpers.call_super_helpers,
                        self.unresolved_mark,
                        self.rewrite_level,
                        var_decl.span,
                    ) {
                        items.push(ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(ExportDecl {
                            span: export_span,
                            decl: Decl::Class(class_decl),
                        })));
                        converted_any = true;
                    } else {
                        items.push(item);
                    }
                }
                other => items.push(other),
            }
        }
        if converted_any {
            remove_orphaned_create_class_helpers_module(
                items,
                &self.helpers.create_class_helpers,
                self.unresolved_mark,
            );
            remove_orphaned_ts_extends_helpers_module(items, &self.helpers.ts_extends_helpers);
            remove_orphaned_fn_helpers_module(items, &self.helpers.inherits_helpers);
            remove_orphaned_fn_helpers_module(items, &self.helpers.set_prototype_of_helpers);
            remove_orphaned_fn_helpers_module(items, &self.helpers.call_super_helpers);
        }
    }
}

fn collect_ts_extends_helpers_from_stmts(stmts: &[Stmt]) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for stmt in stmts {
        let Stmt::Decl(Decl::Var(var_decl)) = stmt else {
            continue;
        };
        for decl in &var_decl.decls {
            let Pat::Ident(binding) = &decl.name else {
                continue;
            };
            let Some(init) = &decl.init else {
                continue;
            };
            if is_ts_extends_helper_init(init) {
                helpers.insert(binding_key(&binding.id));
            }
        }
    }
    helpers
}

fn collect_ts_extends_helpers_from_items(items: &[ModuleItem]) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for item in items {
        let ModuleItem::Stmt(stmt) = item else {
            continue;
        };
        helpers.extend(collect_ts_extends_helpers_from_stmts(std::slice::from_ref(
            stmt,
        )));
    }
    helpers
}

fn collect_tslib_namespaces_from_stmts(
    stmts: &[Stmt],
    unresolved_mark: Mark,
) -> HashSet<BindingKey> {
    let mut namespaces = HashSet::new();
    for stmt in stmts {
        let Stmt::Decl(Decl::Var(var_decl)) = stmt else {
            continue;
        };
        for decl in &var_decl.decls {
            let Pat::Ident(binding) = &decl.name else {
                continue;
            };
            let Some(init) = decl.init.as_deref() else {
                continue;
            };
            if is_tslib_require_expr_with_mark(init, unresolved_mark) {
                namespaces.insert(binding_key(&binding.id));
            }
        }
    }
    namespaces
}

fn collect_tslib_namespaces_from_items(
    items: &[ModuleItem],
    unresolved_mark: Mark,
) -> HashSet<BindingKey> {
    let mut namespaces = HashSet::new();
    for item in items {
        match item {
            ModuleItem::ModuleDecl(ModuleDecl::Import(import))
                if !import.type_only && is_tslib_path(import.src.value.as_str().unwrap_or("")) =>
            {
                for specifier in &import.specifiers {
                    match specifier {
                        ImportSpecifier::Default(default) => {
                            namespaces.insert(binding_key(&default.local));
                        }
                        ImportSpecifier::Namespace(namespace) => {
                            namespaces.insert(binding_key(&namespace.local));
                        }
                        ImportSpecifier::Named(_) => {}
                    }
                }
            }
            ModuleItem::Stmt(stmt) => {
                namespaces.extend(collect_tslib_namespaces_from_stmts(
                    std::slice::from_ref(stmt),
                    unresolved_mark,
                ));
            }
            _ => {}
        }
    }
    namespaces
}

fn collect_tslib_extends_helpers_from_stmts(
    stmts: &[Stmt],
    namespaces: &HashSet<BindingKey>,
    unresolved_mark: Mark,
) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for stmt in stmts {
        let Stmt::Decl(Decl::Var(var_decl)) = stmt else {
            continue;
        };
        for decl in &var_decl.decls {
            let Pat::Ident(binding) = &decl.name else {
                continue;
            };
            let Some(init) = decl.init.as_deref() else {
                continue;
            };
            if is_tslib_extends_member(init, namespaces, unresolved_mark) {
                helpers.insert(binding_key(&binding.id));
            }
        }
    }
    helpers
}

fn collect_tslib_extends_helpers_from_items(
    items: &[ModuleItem],
    namespaces: &HashSet<BindingKey>,
    unresolved_mark: Mark,
) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for item in items {
        match item {
            ModuleItem::ModuleDecl(ModuleDecl::Import(import))
                if !import.type_only && is_tslib_path(import.src.value.as_str().unwrap_or("")) =>
            {
                for specifier in &import.specifiers {
                    let ImportSpecifier::Named(named) = specifier else {
                        continue;
                    };
                    let imported = named
                        .imported
                        .as_ref()
                        .map(module_export_name_as_str)
                        .unwrap_or(named.local.sym.as_ref());
                    if imported == "__extends" {
                        helpers.insert(binding_key(&named.local));
                    }
                }
            }
            ModuleItem::Stmt(stmt) => {
                helpers.extend(collect_tslib_extends_helpers_from_stmts(
                    std::slice::from_ref(stmt),
                    namespaces,
                    unresolved_mark,
                ));
            }
            _ => {}
        }
    }
    helpers
}

fn module_export_name_as_str(name: &ModuleExportName) -> &str {
    match name {
        ModuleExportName::Ident(ident) => ident.sym.as_ref(),
        ModuleExportName::Str(str_) => str_.value.as_str().unwrap_or(""),
    }
}

fn is_tslib_extends_member(
    expr: &Expr,
    namespaces: &HashSet<BindingKey>,
    unresolved_mark: Mark,
) -> bool {
    tslib_require_ts_helper_kind_with_mark(expr, unresolved_mark) == Some(TsHelperKind::Extends)
        || tslib_member_ts_helper_kind(expr, namespaces) == Some(TsHelperKind::Extends)
}

fn is_ts_extends_helper_init(expr: &Expr) -> bool {
    let Expr::Bin(or_expr) = strip_parens(expr) else {
        return false;
    };
    if or_expr.op != swc_core::ecma::ast::BinaryOp::LogicalOr {
        return false;
    }
    if !is_this_helper_member(&or_expr.left, "__extends") {
        return false;
    }
    let rhs = strip_parens(&or_expr.right);
    extract_iife_call(rhs).is_some() || matches!(rhs, Expr::Fn(_) | Expr::Arrow(_))
}

fn is_this_helper_member(expr: &Expr, helper_name: &str) -> bool {
    let Expr::Bin(and_expr) = strip_parens(expr) else {
        return false;
    };
    if and_expr.op != swc_core::ecma::ast::BinaryOp::LogicalAnd {
        return false;
    }
    if !matches!(strip_parens(&and_expr.left), Expr::This(_)) {
        return false;
    }
    let Expr::Member(member) = strip_parens(&and_expr.right) else {
        return false;
    };
    matches!(member.obj.as_ref(), Expr::This(_))
        && matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == helper_name)
}

fn collect_set_prototype_of_helpers_from_stmts(stmts: &[Stmt]) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for stmt in stmts {
        if let Stmt::Decl(Decl::Fn(fn_decl)) = stmt {
            if is_set_prototype_of_fn(&fn_decl.function) {
                helpers.insert(binding_key(&fn_decl.ident));
            }
        }
    }
    helpers
}

fn collect_set_prototype_of_helpers_from_items(items: &[ModuleItem]) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for item in items {
        if let ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) = item {
            if is_set_prototype_of_fn(&fn_decl.function) {
                helpers.insert(binding_key(&fn_decl.ident));
            }
        }
    }
    helpers
}

/// Collect names of functions that match the `_inherits` body shape from statements.
fn collect_inherits_helpers_from_stmts(stmts: &[Stmt]) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for stmt in stmts {
        if let Stmt::Decl(Decl::Fn(fn_decl)) = stmt {
            if is_inherits_fn(&fn_decl.function) {
                helpers.insert(binding_key(&fn_decl.ident));
            }
        }
    }
    helpers
}

/// Collect names of functions that match the `_inherits` body shape from module items.
fn collect_inherits_helpers_from_items(items: &[ModuleItem]) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for item in items {
        if let ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) = item {
            if is_inherits_fn(&fn_decl.function) {
                helpers.insert(binding_key(&fn_decl.ident));
            }
        }
    }
    helpers
}

/// Collect names of functions that match the `_callSuper` body shape from statements.
fn collect_call_super_helpers_from_stmts(stmts: &[Stmt]) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for stmt in stmts {
        if let Stmt::Decl(Decl::Fn(fn_decl)) = stmt {
            if is_call_super_fn(&fn_decl.function) {
                helpers.insert(binding_key(&fn_decl.ident));
            }
        }
    }
    helpers
}

/// Collect names of functions that match the `_callSuper` body shape from module items.
fn collect_call_super_helpers_from_items(items: &[ModuleItem]) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for item in items {
        if let ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) = item {
            if is_call_super_fn(&fn_decl.function) {
                helpers.insert(binding_key(&fn_decl.ident));
            }
        }
    }
    helpers
}

// ============================================================
// _createClass helper detection (body-shape matching)
// ============================================================

/// Collect names of variables whose init is a _createClass IIFE from statements.
fn collect_create_class_helpers_from_stmts(
    stmts: &[Stmt],
    unresolved_mark: Mark,
) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for stmt in stmts {
        match stmt {
            Stmt::Decl(Decl::Fn(fn_decl)) => {
                if let Some(name) = detect_create_class_fn(&fn_decl.ident, &fn_decl.function) {
                    helpers.insert(name);
                }
            }
            Stmt::Decl(Decl::Var(var_decl)) => {
                if let Some(name) = detect_create_class_var(var_decl, unresolved_mark) {
                    helpers.insert(name);
                }
            }
            _ => {}
        }
    }
    helpers
}

/// Collect names of _createClass helpers from module items.
fn collect_create_class_helpers_from_items(
    items: &[ModuleItem],
    unresolved_mark: Mark,
) -> HashSet<BindingKey> {
    let mut helpers = HashSet::new();
    for item in items {
        match item {
            ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) => {
                if let Some(name) = detect_create_class_fn(&fn_decl.ident, &fn_decl.function) {
                    helpers.insert(name);
                }
            }
            ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) => {
                if let Some(name) = detect_create_class_var(var_decl, unresolved_mark) {
                    helpers.insert(name);
                }
            }
            _ => {}
        }
    }
    helpers
}

fn detect_create_class_fn(ident: &Ident, function: &Function) -> Option<BindingKey> {
    if is_create_class_function(function) {
        Some(binding_key(ident))
    } else {
        None
    }
}

fn is_create_class_function(function: &Function) -> bool {
    use swc_core::ecma::visit::{Visit, VisitWith};

    let Some(first_param) = function.params.first() else {
        return false;
    };
    let Pat::Ident(constructor) = &first_param.pat else {
        return false;
    };
    let Some(body) = &function.body else {
        return false;
    };
    if !body.stmts.iter().any(|stmt| {
        matches!(stmt, Stmt::Return(ret) if ret.arg.as_ref().is_some_and(|arg| {
            matches!(arg.as_ref(), Expr::Ident(id) if id.sym == constructor.id.sym && id.ctxt == constructor.id.ctxt)
        }))
    }) {
        return false;
    }

    struct PrototypeDefineCallFinder {
        constructor: Ident,
        found: bool,
    }

    impl Visit for PrototypeDefineCallFinder {
        fn visit_call_expr(&mut self, call: &CallExpr) {
            if self.found {
                return;
            }
            let Some(first_arg) = call.args.first() else {
                call.visit_children_with(self);
                return;
            };
            if let Expr::Member(member) = strip_parens(&first_arg.expr) {
                if let Expr::Ident(obj) = member.obj.as_ref() {
                    if obj.sym == self.constructor.sym
                        && obj.ctxt == self.constructor.ctxt
                        && matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "prototype")
                    {
                        self.found = true;
                        return;
                    }
                }
            }
            call.visit_children_with(self);
        }
    }

    let mut finder = PrototypeDefineCallFinder {
        constructor: constructor.id.clone(),
        found: false,
    };
    body.visit_with(&mut finder);
    finder.found
}

/// If a VarDecl is `var r = (function() { ... createClass body ... })()`, return the name `r`.
fn detect_create_class_var(var_decl: &VarDecl, unresolved_mark: Mark) -> Option<BindingKey> {
    if var_decl.decls.len() != 1 {
        return None;
    }
    let decl = &var_decl.decls[0];
    let Pat::Ident(bi) = &decl.name else {
        return None;
    };
    let init = decl.init.as_ref()?;
    let call = extract_iife_call(init)?;
    if !call.args.is_empty() {
        return None;
    }

    // Get the IIFE body
    let Callee::Expr(callee) = &call.callee else {
        return None;
    };
    let body_stmts = get_fn_or_arrow_body(strip_parens(callee))?;

    if is_create_class_body(body_stmts, unresolved_mark) {
        Some(binding_key(&bi.id))
    } else {
        None
    }
}

/// Check if statements form the `_createClass` body:
/// - Contains a function with `Object.defineProperty(e, r.key, r)` in a for loop
/// - Returns a function that references `.prototype`
fn is_create_class_body(stmts: &[Stmt], unresolved_mark: Mark) -> bool {
    use swc_core::ecma::visit::{Visit, VisitWith};

    // Must have a function declaration and a return statement
    let has_fn_decl = stmts.iter().any(|s| matches!(s, Stmt::Decl(Decl::Fn(_))));
    let has_return = stmts.iter().any(|s| matches!(s, Stmt::Return(_)));
    if !has_fn_decl || !has_return {
        return false;
    }

    // The inner function must contain `Object.defineProperty(_, _.key, _)`
    struct CreateClassDetector {
        has_define_property_key: bool,
        unresolved_mark: Mark,
    }
    impl Visit for CreateClassDetector {
        fn visit_call_expr(&mut self, call: &CallExpr) {
            if let Callee::Expr(callee) = &call.callee {
                // Check for Object.defineProperty
                if let Expr::Member(m) = callee.as_ref() {
                    if let Expr::Ident(obj) = m.obj.as_ref() {
                        if is_unresolved_ident(obj, "Object", self.unresolved_mark) {
                            if let MemberProp::Ident(prop) = &m.prop {
                                if prop.sym.as_ref() == "defineProperty" && call.args.len() >= 3 {
                                    // Check if second arg accesses `.key`
                                    let arg1 = strip_parens(&call.args[1].expr);
                                    if let Expr::Member(m) = arg1 {
                                        if let MemberProp::Ident(p) = &m.prop {
                                            if p.sym.as_ref() == "key" {
                                                self.has_define_property_key = true;
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            call.visit_children_with(self);
        }
    }

    let mut detector = CreateClassDetector {
        has_define_property_key: false,
        unresolved_mark,
    };
    stmts.visit_with(&mut detector);
    detector.has_define_property_key
}

/// Get the body statements from a function or arrow expression.
fn get_fn_or_arrow_body(expr: &Expr) -> Option<&[Stmt]> {
    match expr {
        Expr::Fn(fn_expr) => fn_expr.function.body.as_ref().map(|b| b.stmts.as_slice()),
        Expr::Arrow(arrow) => match &*arrow.body {
            BlockStmtOrExpr::BlockStmt(block) => Some(&block.stmts),
            _ => None,
        },
        _ => None,
    }
}

// ============================================================
// Orphaned helper removal
// ============================================================

/// Remove _createClass helpers that are no longer referenced after class IIFE
/// conversion. Only removes when there are no remaining references.
fn remove_orphaned_create_class_helpers(
    stmts: &mut Vec<Stmt>,
    helpers: &HashSet<BindingKey>,
    unresolved_mark: Mark,
) {
    remove_unreferenced_helpers(stmts, helpers, |stmt| {
        detect_create_class_stmt_key(stmt, unresolved_mark)
    });
}

fn remove_orphaned_create_class_helpers_module(
    items: &mut Vec<ModuleItem>,
    helpers: &HashSet<BindingKey>,
    unresolved_mark: Mark,
) {
    remove_unreferenced_helpers(items, helpers, |item| {
        detect_create_class_item_key(item, unresolved_mark)
    });
}

fn detect_create_class_stmt_key(stmt: &Stmt, unresolved_mark: Mark) -> Option<BindingKey> {
    match stmt {
        Stmt::Decl(Decl::Fn(fn_decl)) => detect_create_class_fn(&fn_decl.ident, &fn_decl.function),
        Stmt::Decl(Decl::Var(var_decl)) => detect_create_class_var(var_decl, unresolved_mark),
        _ => None,
    }
}

fn detect_create_class_item_key(item: &ModuleItem, unresolved_mark: Mark) -> Option<BindingKey> {
    match item {
        ModuleItem::Stmt(stmt) => detect_create_class_stmt_key(stmt, unresolved_mark),
        ModuleItem::ModuleDecl(ModuleDecl::Import(import))
            if import.specifiers.len() == 1
                && import
                    .src
                    .value
                    .as_str()
                    .is_some_and(|p| detect_helper_from_path(p).is_some()) =>
        {
            match &import.specifiers[0] {
                ImportSpecifier::Default(spec) => Some(binding_key(&spec.local)),
                ImportSpecifier::Named(spec) => Some(binding_key(&spec.local)),
                _ => None,
            }
        }
        _ => None,
    }
}

fn remove_orphaned_ts_extends_helpers_stmts(stmts: &mut Vec<Stmt>, helpers: &HashSet<BindingKey>) {
    remove_unreferenced_helpers(stmts, helpers, |stmt| {
        let Stmt::Decl(Decl::Var(var_decl)) = stmt else {
            return None;
        };
        ts_extends_helper_decl_key(var_decl)
    });
}

fn remove_orphaned_ts_extends_helpers_module(
    items: &mut Vec<ModuleItem>,
    helpers: &HashSet<BindingKey>,
) {
    remove_unreferenced_helpers(items, helpers, |item| {
        let ModuleItem::Stmt(Stmt::Decl(Decl::Var(var_decl))) = item else {
            return None;
        };
        ts_extends_helper_decl_key(var_decl)
    });
}

fn ts_extends_helper_decl_key(var_decl: &VarDecl) -> Option<BindingKey> {
    if var_decl.decls.len() != 1 {
        return None;
    }
    let decl = &var_decl.decls[0];
    let Pat::Ident(binding) = &decl.name else {
        return None;
    };
    if !decl.init.as_deref().is_some_and(is_ts_extends_helper_init) {
        return None;
    }
    Some(binding_key(&binding.id))
}

struct BindingHelperRefCounter {
    helpers: HashSet<BindingKey>,
    counts: std::collections::HashMap<BindingKey, usize>,
}

impl BindingHelperRefCounter {
    fn new(helpers: &HashSet<BindingKey>) -> Self {
        Self {
            helpers: helpers.clone(),
            counts: std::collections::HashMap::new(),
        }
    }
}

impl swc_core::ecma::visit::Visit for BindingHelperRefCounter {
    fn visit_ident(&mut self, id: &Ident) {
        let key = binding_key(id);
        if self.helpers.contains(&key) {
            *self.counts.entry(key).or_insert(0) += 1;
        }
    }
}

/// Count references to `helpers` (skipping declarations identified by
/// `helper_key`), then remove declarations with zero remaining references.
fn remove_unreferenced_helpers<T>(
    items: &mut Vec<T>,
    helpers: &HashSet<BindingKey>,
    helper_key: impl Fn(&T) -> Option<BindingKey>,
) where
    T: VisitWith<BindingHelperRefCounter>,
{
    if helpers.is_empty() {
        return;
    }
    let mut counter = BindingHelperRefCounter::new(helpers);
    for item in items.iter() {
        if helper_key(item)
            .as_ref()
            .is_some_and(|key| helpers.contains(key))
        {
            continue;
        }
        item.visit_with(&mut counter);
    }
    items.retain(|item| {
        if let Some(key) = helper_key(item) {
            if helpers.contains(&key) {
                return counter.counts.get(&key).copied().unwrap_or(0) > 0;
            }
        }
        true
    });
}

fn remove_orphaned_fn_helpers_stmts(stmts: &mut Vec<Stmt>, helpers: &HashSet<BindingKey>) {
    remove_unreferenced_helpers(stmts, helpers, |stmt| {
        if let Stmt::Decl(Decl::Fn(fn_decl)) = stmt {
            Some(binding_key(&fn_decl.ident))
        } else {
            None
        }
    });
}

fn remove_orphaned_fn_helpers_module(items: &mut Vec<ModuleItem>, helpers: &HashSet<BindingKey>) {
    remove_unreferenced_helpers(items, helpers, |item| match item {
        ModuleItem::Stmt(Stmt::Decl(Decl::Fn(fn_decl))) => Some(binding_key(&fn_decl.ident)),
        ModuleItem::ModuleDecl(ModuleDecl::Import(import))
            if import.specifiers.len() == 1
                && import
                    .src
                    .value
                    .as_str()
                    .is_some_and(|p| detect_helper_from_path(p).is_some()) =>
        {
            match &import.specifiers[0] {
                ImportSpecifier::Default(spec) => Some(binding_key(&spec.local)),
                ImportSpecifier::Named(spec) => Some(binding_key(&spec.local)),
                _ => None,
            }
        }
        _ => None,
    });
}

// ============================================================
// Core transformation
// ============================================================

/// Attempt to convert a `var Foo = (function(...) { ... }(...))` pattern into a ClassDecl.
/// Returns None if the pattern doesn't match.
#[allow(clippy::too_many_arguments)]
fn try_iife_to_class(
    var: &VarDecl,
    inherits_helpers: &HashSet<BindingKey>,
    tslib_namespaces: &HashSet<BindingKey>,
    create_class_helpers: &HashSet<BindingKey>,
    call_super_helpers: &HashSet<BindingKey>,
    unresolved_mark: Mark,
    rewrite_level: RewriteLevel,
    original_span: Span,
) -> Option<ClassDecl> {
    // Must be a single declarator
    if var.decls.len() != 1 {
        return None;
    }
    let declarator = &var.decls[0];

    // Name must be a plain identifier
    let Pat::Ident(BindingIdent { id: class_name, .. }) = &declarator.name else {
        return None;
    };

    // Must have an initializer
    let init = declarator.init.as_ref()?;

    // The init must be an IIFE call expression (possibly paren-wrapped)
    let call = extract_iife_call(init)?;

    // Callee must be a function or arrow expression (possibly paren-wrapped)
    let Callee::Expr(callee_expr) = &call.callee else {
        return None;
    };
    let callee_inner = strip_parens(callee_expr);

    // Extract params and body from either FnExpr or ArrowExpr
    let (param_pats, body_stmts): (Vec<&Pat>, &[Stmt]) = match callee_inner {
        Expr::Fn(fn_expr) => {
            let body = fn_expr.function.body.as_ref()?;
            let pats: Vec<&Pat> = fn_expr.function.params.iter().map(|p| &p.pat).collect();
            (pats, &body.stmts)
        }
        Expr::Arrow(arrow) => {
            let BlockStmtOrExpr::BlockStmt(block) = &*arrow.body else {
                return None;
            };
            let pats: Vec<&Pat> = arrow.params.iter().collect();
            (pats, &block.stmts)
        }
        _ => return None,
    };

    // The IIFE takes 0 args (no extends) or 1 arg (extends from _super)
    let (mut super_class, inner_param): (Option<Box<Expr>>, Option<Atom>) = match call.args.len() {
        0 => {
            // 0-arg IIFE — may still have inheritance via inline _inherits IIFE.
            // Allow unused params (older Babel output keeps the _super param but
            // passes the super class directly to the inline _inherits call).
            (None, None)
        }
        1 => {
            if param_pats.len() != 1 {
                return None;
            }
            let Pat::Ident(BindingIdent { id: param_id, .. }) = param_pats[0] else {
                return None;
            };
            let super_expr = call.args[0].expr.clone();
            (Some(super_expr), Some(param_id.sym.clone()))
        }
        _ => return None,
    };

    // 0-arg IIFE with 0 params: no super class (standard case)
    // 0-arg IIFE with 1+ params: unused super param, check for inline inherits
    if call.args.is_empty() && !param_pats.is_empty() {
        // Scan body for inline _inherits IIFE to discover the super class.
        // If found, super_class is extracted from the inline call's second argument.
        super_class = Some(find_inline_inherits_super(body_stmts, unresolved_mark)?);
    }

    let inner_ctor_ident = find_inner_constructor_ident(body_stmts)?;
    let inner_ctor_name = inner_ctor_ident.sym.as_ref();
    let class_body = parse_class_body(
        body_stmts,
        &class_name.sym,
        inner_param.as_deref(),
        inherits_helpers,
        tslib_namespaces,
        create_class_helpers,
        call_super_helpers,
        super_class.is_some(),
        rewrite_level >= RewriteLevel::Standard,
        unresolved_mark,
    )?;
    if class_name.sym.as_ref() != inner_ctor_name
        && class_members_reference_binding(
            &class_body,
            &inner_ctor_ident.sym,
            inner_ctor_ident.ctxt,
        )
    {
        return None;
    }

    // Use the original statement's span for the class so that source maps
    // can map the synthesized class back to the input IIFE/var declaration.
    let class_span = if original_span.lo.0 != 0 {
        original_span
    } else {
        DUMMY_SP
    };

    Some(ClassDecl {
        ident: class_name.clone(),
        declare: false,
        class: Box::new(Class {
            span: class_span,
            ctxt: Default::default(),
            decorators: vec![],
            body: class_body,
            super_class,
            is_abstract: false,
            type_params: None,
            super_type_params: None,
            implements: vec![],
        }),
    })
}

fn class_members_reference_binding(
    members: &[ClassMember],
    name: &Atom,
    ctxt: SyntaxContext,
) -> bool {
    use swc_core::ecma::visit::{Visit, VisitWith};

    struct Finder<'a> {
        name: &'a Atom,
        ctxt: SyntaxContext,
        found: bool,
    }

    impl Visit for Finder<'_> {
        fn visit_ident(&mut self, id: &Ident) {
            if &id.sym == self.name && id.ctxt == self.ctxt {
                self.found = true;
            }
        }
    }

    let mut finder = Finder {
        name,
        ctxt,
        found: false,
    };
    members.visit_with(&mut finder);
    finder.found
}

/// Scan an IIFE body for an inline `_inherits` IIFE call and extract the super class expression.
///
/// Pattern: `((e, t) => { ... Object.create ... })(t, SuperClass)`
/// where the first arg is the constructor name and the second arg is the super class.
fn find_inline_inherits_super(stmts: &[Stmt], unresolved_mark: Mark) -> Option<Box<Expr>> {
    let inner_ctor_name = find_inner_constructor_name(stmts)?;
    for stmt in stmts {
        let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
            continue;
        };
        let Expr::Call(call) = expr.as_ref() else {
            continue;
        };
        let Callee::Expr(callee) = &call.callee else {
            continue;
        };

        if call.args.len() != 2 {
            continue;
        }

        // First arg must be the constructor
        let arg0 = strip_parens(&call.args[0].expr);
        if !matches!(arg0, Expr::Ident(id) if id.sym.as_ref() == inner_ctor_name) {
            continue;
        }

        // Callee must be an inline fn/arrow with Object.create in its body
        let inner = strip_parens(callee);
        let body_stmts = match inner {
            Expr::Arrow(arrow) if arrow.params.len() == 2 => match &*arrow.body {
                BlockStmtOrExpr::BlockStmt(block) => &block.stmts[..],
                _ => continue,
            },
            Expr::Fn(fn_expr) if fn_expr.function.params.len() == 2 => {
                match &fn_expr.function.body {
                    Some(block) => &block.stmts[..],
                    None => continue,
                }
            }
            _ => continue,
        };

        if body_stmts
            .iter()
            .any(|s| stmt_has_object_create(s, unresolved_mark))
        {
            // This is an inline _inherits IIFE — second arg is the super class
            return Some(call.args[1].expr.clone());
        }
    }
    None
}

// ============================================================
// IIFE structure helpers
// ============================================================

/// Strip parentheses and try to extract the inner CallExpr that represents the IIFE invocation.
///
/// Handles both function and arrow IIFEs:
///   `(function() { ... }())` / `(function() { ... })()`
///   `((e) => { ... })(arg)`
fn extract_iife_call(expr: &Expr) -> Option<&CallExpr> {
    let stripped = strip_parens(expr);
    match stripped {
        Expr::Call(call) => {
            let Callee::Expr(callee) = &call.callee else {
                return None;
            };
            let inner = strip_parens(callee);
            if matches!(inner, Expr::Fn(_) | Expr::Arrow(_)) {
                Some(call)
            } else {
                None
            }
        }
        _ => None,
    }
}

// ============================================================
// Class body parsing
// ============================================================

/// Parse the statements inside the IIFE body and collect class members.
///
/// `class_name` — the outer variable name (e.g. `"Foo"`)
/// `super_param` — the IIFE parameter name that represents `_super` (if inheriting)
/// `has_super` — true when a super class was discovered (either from IIFE arg or inline inherits)
///
/// Returns None if any statement is unrecognised (conservative — no false positives).
#[allow(clippy::too_many_arguments)]
fn parse_class_body(
    stmts: &[Stmt],
    class_name: &str,
    super_param: Option<&str>,
    inherits_helpers: &HashSet<BindingKey>,
    tslib_namespaces: &HashSet<BindingKey>,
    create_class_helpers: &HashSet<BindingKey>,
    call_super_helpers: &HashSet<BindingKey>,
    has_super: bool,
    allow_static_fields: bool,
    unresolved_mark: Mark,
) -> Option<Vec<ClassMember>> {
    // The first real statement should define the constructor function.
    // We need to identify the inner constructor function name (often mangled, e.g. `t`).
    let inner_ctor_name = find_inner_constructor_name(stmts)?;

    let mut members: Vec<ClassMember> = Vec::new();
    // Tracks whether we've seen and handled the `__extends` / `_inherits` call
    let mut extends_handled = false;
    // Tracks an alias for `t.prototype` introduced in Babel loose mode:
    //   `var proto = t.prototype;`
    let mut proto_alias: Option<Atom> = None;

    // Determine if the constructor should have super() rewriting.
    // When super_param is set, use it. When has_super is true but super_param is None
    // (inline _inherits pattern), we still need to rewrite super calls.
    let needs_super_rewrite = super_param.is_some() || has_super;

    for stmt in stmts {
        // `return t;` or `return _createClass(t, ...)` or
        // `return t.method1 = fn, t.method2 = fn, ..., t;` — end of IIFE body
        if let Stmt::Return(ret_stmt) = stmt {
            if let Some(ret_expr) = &ret_stmt.arg {
                let stripped = strip_parens(ret_expr);
                match stripped {
                    // Plain `return t;`
                    Expr::Ident(id) if id.sym.as_ref() == inner_ctor_name => {
                        // Nothing to do
                    }
                    // `return _createClass(t, [{ key: "method", value: fn }], [{ ... }])`
                    Expr::Call(call) => {
                        if !try_parse_create_class(
                            call,
                            inner_ctor_name,
                            &mut members,
                            create_class_helpers,
                            unresolved_mark,
                        ) {
                            return None;
                        }
                    }
                    // `return t.method = fn, t.method2 = fn, ..., t;`
                    // Minified Babel loose: method assignments in comma/sequence expression
                    Expr::Seq(seq) => {
                        if !try_parse_seq_return(seq, inner_ctor_name, &proto_alias, &mut members) {
                            return None;
                        }
                    }
                    _ => return None,
                }
            }
            continue;
        }

        // `__extends(t, _super)` or `_inherits(t, _super)` or `customInherits(t, _super)`,
        // or inline IIFE: `((e, t) => { Object.create... })(t, _super)`
        if let Some(sp) = super_param {
            if try_parse_extends_call(
                stmt,
                inner_ctor_name,
                sp,
                inherits_helpers,
                tslib_namespaces,
                unresolved_mark,
            )
            .is_some()
                || is_inline_inherits_iife(stmt, inner_ctor_name, sp, unresolved_mark)
            {
                extends_handled = true;
                continue;
            }
        }

        // Inline _inherits IIFE with super class baked in (0-arg IIFE pattern):
        // `((e, t) => { ... Object.create ... })(t, SuperClass)`
        // When super_param is None but has_super is true, we already extracted the super class
        // in find_inline_inherits_super — just skip this statement.
        if super_param.is_none()
            && has_super
            && is_inline_inherits_iife_any_super(stmt, inner_ctor_name, unresolved_mark)
        {
            extends_handled = true;
            continue;
        }

        // `function t(...) { ... }` — the constructor
        if let Stmt::Decl(Decl::Fn(fn_decl)) = stmt {
            if fn_decl.ident.sym.as_ref() == inner_ctor_name {
                // For super rewriting, we need a param name to match against.
                // When we have super_param, use it directly.
                // When super was discovered via inline inherits, use a synthetic marker
                // that triggers the PCR unwrap + super rewriting heuristics.
                let ctor_super_param = if needs_super_rewrite {
                    super_param.or(Some("__super__"))
                } else {
                    None
                };
                let ctor = build_constructor(
                    &fn_decl.function,
                    inner_ctor_name,
                    ctor_super_param,
                    call_super_helpers,
                    unresolved_mark,
                )?;
                // Omit the constructor if it's empty or is the default derived
                // constructor: `constructor() { super(...arguments); }`
                if !is_default_constructor(&ctor) {
                    members.push(ClassMember::Constructor(ctor));
                }
                continue;
            }
            return None;
        }

        // Expression statements
        if let Stmt::Expr(ExprStmt { expr, .. }) = stmt {
            // `t.prototype.method = function() { ... }`
            // `t.staticMethod = function() { ... }`
            // `t.prototype = Object.create(_super.prototype)` (inheritance setup — skip)
            // `Object.defineProperty(t.prototype, "prop", { get: fn, set: fn })`
            if try_parse_method_assignment(expr, inner_ctor_name, &proto_alias, &mut members) {
                continue;
            }

            // `t.staticField = value`
            //
            // In derived classes this is observably different from a static
            // field if the superclass has a setter for that property.
            if allow_static_fields
                && !has_super
                && try_parse_static_field_assignment(expr, inner_ctor_name, &mut members)
            {
                continue;
            }

            // Babel loose mode: `Object.defineProperty(t.prototype, ...)`
            if try_parse_object_define_property(
                expr,
                inner_ctor_name,
                &proto_alias,
                &mut members,
                unresolved_mark,
            ) {
                continue;
            }

            // Skip `t.prototype = Object.create(...)` (prototype chain setup for inheritance)
            if is_prototype_object_create(expr, inner_ctor_name, unresolved_mark) {
                if has_super || super_param.is_some() {
                    extends_handled = true;
                }
                continue;
            }

            // Skip `t.prototype.constructor = t` (redundant constructor assignment)
            if is_prototype_constructor_assign(expr, inner_ctor_name) {
                continue;
            }

            // Skip inlined `_super && (Object.setPrototypeOf ? ...)` (static prototype chain)
            if let Some(sp) = super_param {
                if is_set_prototype_of_chain_expr(expr, sp, unresolved_mark) {
                    extends_handled = true;
                    continue;
                }
            }

            // `_createClass(t, [...], [...])` or `r(t, [...])` as a statement (Babel non-loose)
            if let Expr::Call(call) = expr.as_ref() {
                if try_parse_create_class(
                    call,
                    inner_ctor_name,
                    &mut members,
                    create_class_helpers,
                    unresolved_mark,
                ) {
                    continue;
                }
            }

            return None;
        }

        // Babel loose mode: `var proto = t.prototype;`
        if let Stmt::Decl(Decl::Var(var_decl)) = stmt {
            if let Some(alias) = try_parse_proto_alias(var_decl, inner_ctor_name) {
                proto_alias = Some(alias);
                continue;
            }
            return None;
        }

        // Skip `if (typeof _super !== "function" && _super !== null) { throw ... }`
        if let Some(sp) = super_param {
            if is_super_typecheck_if_stmt(stmt, sp) {
                continue;
            }
        }

        return None;
    }

    // If there's a super class but we never saw __extends, reject
    if (super_param.is_some() || has_super) && !extends_handled {
        return None;
    }

    let _ = class_name; // used only for documentation purposes
    Some(members)
}

/// Like `is_inline_inherits_iife` but doesn't check the second argument against a specific param name.
/// Used when the super class was passed inline (not via IIFE param).
fn is_inline_inherits_iife_any_super(stmt: &Stmt, ctor_name: &str, unresolved_mark: Mark) -> bool {
    let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
        return false;
    };
    let Expr::Call(call) = expr.as_ref() else {
        return false;
    };
    let Callee::Expr(callee) = &call.callee else {
        return false;
    };

    if call.args.len() != 2 {
        return false;
    }
    let arg0 = strip_parens(&call.args[0].expr);
    if !matches!(arg0, Expr::Ident(id) if id.sym.as_ref() == ctor_name) {
        return false;
    }

    let inner = strip_parens(callee);
    let body_stmts = match inner {
        Expr::Arrow(arrow) if arrow.params.len() == 2 => match &*arrow.body {
            BlockStmtOrExpr::BlockStmt(block) => &block.stmts[..],
            _ => return false,
        },
        Expr::Fn(fn_expr) if fn_expr.function.params.len() == 2 => match &fn_expr.function.body {
            Some(block) => &block.stmts[..],
            None => return false,
        },
        _ => return false,
    };

    body_stmts
        .iter()
        .any(|s| stmt_has_object_create(s, unresolved_mark))
}

// ============================================================
// Statement parsers
// ============================================================

/// Detect `__extends(t, _super)`, `_inherits(t, _super)`, or a call to a detected inherits helper.
fn try_parse_extends_call(
    stmt: &Stmt,
    ctor_name: &str,
    super_param: &str,
    inherits_helpers: &HashSet<BindingKey>,
    tslib_namespaces: &HashSet<BindingKey>,
    unresolved_mark: Mark,
) -> Option<()> {
    let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
        return None;
    };
    let Expr::Call(call) = expr.as_ref() else {
        return None;
    };
    let Callee::Expr(callee) = &call.callee else {
        return None;
    };
    let callee = strip_parens(callee);
    let is_helper = match callee {
        Expr::Ident(fn_name) => {
            // Accept collected helper bindings, or unresolved built-in helper names.
            // A local IIFE param named `_inherits` / `__extends` must not be treated as
            // a helper purely by symbol.
            let is_unresolved_builtin = matches!(fn_name.sym.as_ref(), "__extends" | "_inherits")
                && fn_name.ctxt.outer() == unresolved_mark;
            is_unresolved_builtin || inherits_helpers.contains(&binding_key(fn_name))
        }
        Expr::Member(_) => is_tslib_extends_member(callee, tslib_namespaces, unresolved_mark),
        _ => false,
    };
    if !is_helper {
        return None;
    }
    if call.args.len() != 2 {
        return None;
    }
    // First arg must be the inner constructor name
    let arg0 = strip_parens(&call.args[0].expr);
    if !matches!(arg0, Expr::Ident(id) if id.sym.as_ref() == ctor_name) {
        return None;
    }
    // Second arg must be the super param
    let arg1 = strip_parens(&call.args[1].expr);
    if !matches!(arg1, Expr::Ident(id) if id.sym.as_ref() == super_param) {
        return None;
    }
    Some(())
}

/// Detect `var proto = t.prototype` (Babel loose mode proto alias).
fn try_parse_proto_alias(var_decl: &VarDecl, ctor_name: &str) -> Option<Atom> {
    if var_decl.decls.len() != 1 {
        return None;
    }
    let d = &var_decl.decls[0];
    let Pat::Ident(BindingIdent { id: alias_id, .. }) = &d.name else {
        return None;
    };
    let init = d.init.as_ref()?;
    // Must be `t.prototype`
    if !is_prototype_member_expr(init, ctor_name) {
        return None;
    }
    Some(alias_id.sym.clone())
}

/// Try to parse `t.prototype.method = function...` or `t.staticProp = function...`
/// or `proto.method = function...` (when `proto_alias` is set).
///
/// Returns true if the expression was recognised and a class member was added.
fn try_parse_method_assignment(
    expr: &Expr,
    ctor_name: &str,
    proto_alias: &Option<Atom>,
    members: &mut Vec<ClassMember>,
) -> bool {
    let Expr::Assign(assign) = expr else {
        return false;
    };
    if assign.op != swc_core::ecma::ast::AssignOp::Assign {
        return false;
    }

    let swc_core::ecma::ast::AssignTarget::Simple(swc_core::ecma::ast::SimpleAssignTarget::Member(
        lhs_member,
    )) = &assign.left
    else {
        return false;
    };

    // Determine if this is a static or prototype method assignment
    //
    // Static:    `t.methodName = function() {}`
    // Prototype: `t.prototype.methodName = function() {}`
    // Loose:     `proto.methodName = function() {}` (proto_alias set)

    let (is_static, method_name) = if let Some(name) =
        extract_static_method_name(&lhs_member.obj, &lhs_member.prop, ctor_name)
    {
        (true, name)
    } else if let Some(name) =
        extract_proto_method_name(&lhs_member.obj, &lhs_member.prop, ctor_name, proto_alias)
    {
        (false, name)
    } else {
        return false;
    };

    // The RHS must be a function expression (named or anonymous)
    let rhs = strip_parens(&assign.right);
    let fn_expr = match rhs {
        Expr::Fn(f) => f,
        _ => return false,
    };

    let method = build_class_method(method_name, fn_expr, is_static, MethodKind::Method);
    members.push(ClassMember::Method(method));
    true
}

fn try_parse_static_field_assignment(
    expr: &Expr,
    ctor_name: &str,
    members: &mut Vec<ClassMember>,
) -> bool {
    let Expr::Assign(assign) = expr else {
        return false;
    };
    if assign.op != AssignOp::Assign {
        return false;
    }

    let AssignTarget::Simple(SimpleAssignTarget::Member(lhs_member)) = &assign.left else {
        return false;
    };

    let Some(key) = extract_static_method_name(&lhs_member.obj, &lhs_member.prop, ctor_name) else {
        return false;
    };
    let rhs = strip_parens(&assign.right);
    if matches!(rhs, Expr::Fn(_)) {
        return false;
    }

    members.push(ClassMember::ClassProp(ClassProp {
        span: DUMMY_SP,
        key,
        value: Some(assign.right.clone()),
        type_ann: None,
        is_static: true,
        decorators: Vec::new(),
        accessibility: None,
        is_abstract: false,
        is_optional: false,
        is_override: false,
        readonly: false,
        declare: false,
        definite: false,
    }));
    true
}

/// Try to parse `Object.defineProperty(t.prototype, "name", { get: fn, set: fn })`
/// or `Object.defineProperty(t.prototype, "name", { value: fn, writable: true, ... })`.
fn try_parse_object_define_property(
    expr: &Expr,
    ctor_name: &str,
    proto_alias: &Option<Atom>,
    members: &mut Vec<ClassMember>,
    unresolved_mark: Mark,
) -> bool {
    let Expr::Call(call) = expr else {
        return false;
    };

    // Callee must be `Object.defineProperty`
    if !is_object_define_property_callee(&call.callee, unresolved_mark) {
        return false;
    }

    if call.args.len() != 3 {
        return false;
    }

    // First arg: `t.prototype` or alias
    let target = strip_parens(&call.args[0].expr);
    let is_proto_target =
        is_prototype_member_expr(target, ctor_name) || is_proto_alias_expr(target, proto_alias);
    if !is_proto_target {
        return false;
    }

    // Second arg: property name (string literal)
    let prop_name_expr = strip_parens(&call.args[1].expr);
    let Expr::Lit(swc_core::ecma::ast::Lit::Str(s)) = prop_name_expr else {
        return false;
    };
    let sym: Atom = s.value.as_str().unwrap_or("").into();

    // Third arg: descriptor object `{ get: fn, set: fn, value: fn, ... }`
    let descriptor = strip_parens(&call.args[2].expr);
    let Expr::Object(obj) = descriptor else {
        return false;
    };

    let original_len = members.len();
    let value_fn = descriptor_value_method_fn(obj);

    for prop in &obj.props {
        let swc_core::ecma::ast::PropOrSpread::Prop(p) = prop else {
            continue;
        };
        let swc_core::ecma::ast::Prop::KeyValue(kv) = p.as_ref() else {
            continue;
        };
        let key_name = match &kv.key {
            PropName::Ident(iden) => iden.sym.clone(),
            PropName::Str(s) => s.value.as_str().unwrap_or("").into(),
            _ => continue,
        };
        let kind = match key_name.as_ref() {
            "get" => MethodKind::Getter,
            "set" => MethodKind::Setter,
            _ => continue,
        };
        let fn_expr = match strip_parens(&kv.value) {
            Expr::Fn(f) => f,
            _ => continue,
        };
        let method_key = PropName::Ident(IdentName::new(sym.clone(), DUMMY_SP));
        let method = build_class_method(method_key, fn_expr, false, kind);
        members.push(ClassMember::Method(method));
    }

    if let Some(fn_expr) = value_fn {
        let method_key = PropName::Ident(IdentName::new(sym, DUMMY_SP));
        let method = build_class_method(method_key, fn_expr, false, MethodKind::Method);
        members.push(ClassMember::Method(method));
    }

    members.len() > original_len
}

fn descriptor_value_method_fn(obj: &swc_core::ecma::ast::ObjectLit) -> Option<&FnExpr> {
    let mut value_fn = None;
    let mut writable = false;
    let mut configurable = false;

    for prop in &obj.props {
        let swc_core::ecma::ast::PropOrSpread::Prop(prop) = prop else {
            return None;
        };
        let swc_core::ecma::ast::Prop::KeyValue(kv) = prop.as_ref() else {
            return None;
        };
        let key_name = prop_name_atom(&kv.key)?;
        match key_name.as_ref() {
            "value" => match strip_parens(&kv.value) {
                Expr::Fn(fn_expr) => value_fn = Some(fn_expr),
                _ => return None,
            },
            "writable" => {
                if !is_bool_literal(&kv.value, true) {
                    return None;
                }
                writable = true;
            }
            "configurable" => {
                if !is_bool_literal(&kv.value, true) {
                    return None;
                }
                configurable = true;
            }
            "enumerable" => {
                if !is_bool_literal(&kv.value, false) {
                    return None;
                }
            }
            _ => return None,
        }
    }

    if writable && configurable {
        value_fn
    } else {
        None
    }
}

fn prop_name_atom(prop: &PropName) -> Option<Atom> {
    match prop {
        PropName::Ident(ident) => Some(ident.sym.clone()),
        PropName::Str(str_lit) => Some(str_lit.value.as_str()?.into()),
        _ => None,
    }
}

fn is_bool_literal(expr: &Expr, value: bool) -> bool {
    matches!(strip_parens(expr), Expr::Lit(Lit::Bool(bool_lit)) if bool_lit.value == value)
}

/// Parse a sequence expression in a return statement:
/// `return proto.method1 = fn, proto.method2 = fn, ..., ClassName;`
///
/// The last expression must be the constructor ident. Each preceding expression
/// must be a method/property assignment.
fn try_parse_seq_return(
    seq: &SeqExpr,
    ctor_name: &str,
    proto_alias: &Option<Atom>,
    members: &mut Vec<ClassMember>,
) -> bool {
    if seq.exprs.is_empty() {
        return false;
    }

    // Last expression must be the constructor ident
    let last = strip_parens(seq.exprs.last().unwrap());
    if !matches!(last, Expr::Ident(id) if id.sym.as_ref() == ctor_name) {
        return false;
    }

    // All preceding expressions must be method assignments
    for expr in &seq.exprs[..seq.exprs.len() - 1] {
        if !try_parse_method_assignment(strip_parens(expr), ctor_name, proto_alias, members) {
            return false;
        }
    }

    true
}

/// Parse `_createClass(t, instanceMethods, staticMethods)` where each methods array
/// contains `{ key: "name", value: function() {} }` objects.
/// Matches unresolved `_createClass` and bindings detected via body-shape matching.
fn try_parse_create_class(
    call: &CallExpr,
    ctor_name: &str,
    members: &mut Vec<ClassMember>,
    create_class_helpers: &HashSet<BindingKey>,
    unresolved_mark: Mark,
) -> bool {
    // Callee must be unresolved `_createClass` or a detected helper binding.
    let Callee::Expr(callee) = &call.callee else {
        return false;
    };
    let is_create_class = match strip_parens(callee) {
        Expr::Ident(id) => {
            let is_unresolved_builtin =
                id.sym.as_ref() == "_createClass" && id.ctxt.outer() == unresolved_mark;
            is_unresolved_builtin || create_class_helpers.contains(&binding_key(id))
        }
        _ => false,
    };
    if !is_create_class {
        return false;
    }

    // Args: (ClassName) or (ClassName, [instance methods], [static methods]?)
    if call.args.is_empty() || call.args.len() > 3 {
        return false;
    }

    // First arg must be the constructor ident
    let arg0 = strip_parens(&call.args[0].expr);
    if !matches!(arg0, Expr::Ident(id) if id.sym.as_ref() == ctor_name) {
        return false;
    }

    // 1-arg form: _createClass(Foo) — just seals prototype, no methods
    if call.args.len() == 1 {
        return true;
    }

    // Instance methods
    if !parse_create_class_array(&call.args[1], false, members) {
        return false;
    }

    // Static methods (optional 3rd arg)
    if call.args.len() == 3 && !parse_create_class_array(&call.args[2], true, members) {
        return false;
    }

    true
}

fn parse_create_class_array(
    arg: &ExprOrSpread,
    is_static: bool,
    members: &mut Vec<ClassMember>,
) -> bool {
    let arr_expr = strip_parens(&arg.expr);
    // Allow `null` for the static array (Babel sometimes passes null)
    if matches!(arr_expr, Expr::Lit(swc_core::ecma::ast::Lit::Null(_))) {
        return true;
    }
    let Expr::Array(arr) = arr_expr else {
        return false;
    };

    for elem in &arr.elems {
        let Some(elem) = elem else {
            continue;
        };
        let Expr::Object(obj) = strip_parens(&elem.expr) else {
            return false;
        };

        let mut key_name: Option<Atom> = None;
        let mut value_fn: Option<&FnExpr> = None;
        let mut method_kind = MethodKind::Method;

        for prop in &obj.props {
            let swc_core::ecma::ast::PropOrSpread::Prop(p) = prop else {
                continue;
            };
            let swc_core::ecma::ast::Prop::KeyValue(kv) = p.as_ref() else {
                return false;
            };
            let k = match &kv.key {
                PropName::Ident(i) => i.sym.clone(),
                PropName::Str(s) => s.value.as_str().unwrap_or("").into(),
                _ => return false,
            };
            match k.as_ref() {
                "key" => {
                    let Expr::Lit(swc_core::ecma::ast::Lit::Str(s)) = strip_parens(&kv.value)
                    else {
                        return false;
                    };
                    key_name = Some(s.value.as_str().unwrap_or("").into());
                }
                "value" => {
                    let Expr::Fn(f) = strip_parens(&kv.value) else {
                        return false;
                    };
                    value_fn = Some(f);
                }
                "get" => {
                    let Expr::Fn(f) = strip_parens(&kv.value) else {
                        return false;
                    };
                    method_kind = MethodKind::Getter;
                    value_fn = Some(f);
                }
                "set" => {
                    let Expr::Fn(f) = strip_parens(&kv.value) else {
                        return false;
                    };
                    method_kind = MethodKind::Setter;
                    value_fn = Some(f);
                }
                // `writable`, `enumerable`, `configurable` — skip
                _ => {}
            }
        }

        let (Some(name_sym), Some(fn_expr)) = (key_name, value_fn) else {
            return false;
        };
        let method_key = PropName::Ident(IdentName::new(name_sym, DUMMY_SP));
        let method = build_class_method(method_key, fn_expr, is_static, method_kind);
        members.push(ClassMember::Method(method));
    }

    true
}

// ============================================================
// Detection helpers
// ============================================================

/// Find the name of the inner constructor function (`t` in the IIFE body).
/// The first `function <name>(...) { ... }` declaration in the body is the constructor.
fn find_inner_constructor_name(stmts: &[Stmt]) -> Option<&str> {
    find_inner_constructor_ident(stmts).map(|id| id.sym.as_ref())
}

fn find_inner_constructor_ident(stmts: &[Stmt]) -> Option<&Ident> {
    for stmt in stmts {
        if let Stmt::Decl(Decl::Fn(fn_decl)) = stmt {
            return Some(&fn_decl.ident);
        }
    }
    None
}

/// Return true if `expr` is `t.prototype` where `t` is `ctor_name`.
fn is_prototype_member_expr(expr: &Expr, ctor_name: &str) -> bool {
    let Expr::Member(MemberExpr { obj, prop, .. }) = expr else {
        return false;
    };
    let Expr::Ident(obj_id) = obj.as_ref() else {
        return false;
    };
    if obj_id.sym.as_ref() != ctor_name {
        return false;
    }
    matches!(prop, MemberProp::Ident(n) if n.sym.as_ref() == "prototype")
}

/// Return true if `expr` matches the proto alias identifier.
fn is_proto_alias_expr(expr: &Expr, proto_alias: &Option<Atom>) -> bool {
    let Some(alias) = proto_alias else {
        return false;
    };
    matches!(expr, Expr::Ident(id) if &id.sym == alias)
}

/// Check if `expr` is `t.prototype = Object.create(...)`.
fn is_prototype_object_create(expr: &Expr, ctor_name: &str, unresolved_mark: Mark) -> bool {
    let Expr::Assign(assign) = expr else {
        return false;
    };
    if assign.op != swc_core::ecma::ast::AssignOp::Assign {
        return false;
    }
    let swc_core::ecma::ast::AssignTarget::Simple(swc_core::ecma::ast::SimpleAssignTarget::Member(
        lhs,
    )) = &assign.left
    else {
        return false;
    };
    // LHS: `t.prototype`
    if !is_prototype_member_expr(
        &Expr::Member(MemberExpr {
            span: DUMMY_SP,
            obj: lhs.obj.clone(),
            prop: lhs.prop.clone(),
        }),
        ctor_name,
    ) {
        return false;
    }
    // RHS: `Object.create(...)`
    let rhs = strip_parens(&assign.right);
    let Expr::Call(call) = rhs else {
        return false;
    };
    let Callee::Expr(callee) = &call.callee else {
        return false;
    };
    is_object_create_callee(callee, unresolved_mark)
}

/// Check if `expr` is `t.prototype.constructor = t`.
fn is_prototype_constructor_assign(expr: &Expr, ctor_name: &str) -> bool {
    let Expr::Assign(assign) = expr else {
        return false;
    };
    if assign.op != swc_core::ecma::ast::AssignOp::Assign {
        return false;
    }
    let swc_core::ecma::ast::AssignTarget::Simple(swc_core::ecma::ast::SimpleAssignTarget::Member(
        lhs,
    )) = &assign.left
    else {
        return false;
    };
    // LHS must be `t.prototype.constructor`
    let Expr::Member(obj_member) = lhs.obj.as_ref() else {
        return false;
    };
    if !is_prototype_member_expr(
        &Expr::Member(MemberExpr {
            span: DUMMY_SP,
            obj: obj_member.obj.clone(),
            prop: obj_member.prop.clone(),
        }),
        ctor_name,
    ) {
        return false;
    }
    if !matches!(&lhs.prop, MemberProp::Ident(n) if n.sym.as_ref() == "constructor") {
        return false;
    }
    // RHS must be `t`
    matches!(strip_parens(&assign.right), Expr::Ident(id) if id.sym.as_ref() == ctor_name)
}

/// Extract the property name for a **static** assignment `t.prop = ...`.
/// Returns `Some(PropName)` if `obj` is the constructor ident and `prop` is a static method name
/// (not `prototype`).
fn extract_static_method_name(obj: &Expr, prop: &MemberProp, ctor_name: &str) -> Option<PropName> {
    let Expr::Ident(obj_id) = obj else {
        return None;
    };
    if obj_id.sym.as_ref() != ctor_name {
        return None;
    }
    match prop {
        MemberProp::Ident(name) => {
            // Skip `t.prototype`
            if name.sym.as_ref() == "prototype" {
                return None;
            }
            Some(PropName::Ident(IdentName::new(name.sym.clone(), DUMMY_SP)))
        }
        MemberProp::Computed(c) => {
            if let Expr::Lit(swc_core::ecma::ast::Lit::Str(s)) = strip_parens(&c.expr) {
                Some(PropName::Str(swc_core::ecma::ast::Str {
                    span: DUMMY_SP,
                    value: s.value.clone(),
                    raw: None,
                }))
            } else {
                Some(PropName::Computed(ComputedPropName {
                    span: DUMMY_SP,
                    expr: c.expr.clone(),
                }))
            }
        }
        _ => None,
    }
}

/// Extract the property name for a **prototype** assignment.
///
/// Handles:
///   `t.prototype.method` where `obj` is `t.prototype`
///   `proto.method` where `obj` is the proto alias
fn extract_proto_method_name(
    obj: &Expr,
    prop: &MemberProp,
    ctor_name: &str,
    proto_alias: &Option<Atom>,
) -> Option<PropName> {
    let obj_is_proto =
        is_prototype_member_expr(obj, ctor_name) || is_proto_alias_expr(obj, proto_alias);
    if !obj_is_proto {
        return None;
    }
    // Skip the constructor property
    if matches!(prop, MemberProp::Ident(n) if n.sym.as_ref() == "constructor") {
        return None;
    }
    match prop {
        MemberProp::Ident(name) => {
            Some(PropName::Ident(IdentName::new(name.sym.clone(), DUMMY_SP)))
        }
        MemberProp::Computed(c) => {
            if let Expr::Lit(swc_core::ecma::ast::Lit::Str(s)) = strip_parens(&c.expr) {
                Some(PropName::Str(swc_core::ecma::ast::Str {
                    span: DUMMY_SP,
                    value: s.value.clone(),
                    raw: None,
                }))
            } else {
                Some(PropName::Computed(ComputedPropName {
                    span: DUMMY_SP,
                    expr: c.expr.clone(),
                }))
            }
        }
        _ => None,
    }
}

fn is_object_define_property_callee(callee: &Callee, unresolved_mark: Mark) -> bool {
    let Callee::Expr(expr) = callee else {
        return false;
    };
    let Expr::Member(m) = strip_parens(expr) else {
        return false;
    };
    let Expr::Ident(obj_id) = m.obj.as_ref() else {
        return false;
    };
    if !is_unresolved_ident(obj_id, "Object", unresolved_mark) {
        return false;
    }
    matches!(&m.prop, MemberProp::Ident(n) if n.sym.as_ref() == "defineProperty")
}

fn is_object_create_callee(expr: &Expr, unresolved_mark: Mark) -> bool {
    let Expr::Member(m) = strip_parens(expr) else {
        return false;
    };
    let Expr::Ident(obj_id) = m.obj.as_ref() else {
        return false;
    };
    if !is_unresolved_ident(obj_id, "Object", unresolved_mark) {
        return false;
    }
    matches!(&m.prop, MemberProp::Ident(n) if n.sym.as_ref() == "create")
}

/// Check `_super && (Object.setPrototypeOf ? Object.setPrototypeOf(t, _super) : t.__proto__ = _super)`.
/// This is the inlined static prototype chain setup emitted by webpack4 instead of `_inherits`.
fn is_set_prototype_of_chain_expr(expr: &Expr, super_param: &str, unresolved_mark: Mark) -> bool {
    let Expr::Bin(bin) = expr else {
        return false;
    };
    if bin.op != swc_core::ecma::ast::BinaryOp::LogicalAnd {
        return false;
    }
    // Left must be the super param ident
    if !matches!(strip_parens(&bin.left), Expr::Ident(id) if id.sym.as_ref() == super_param) {
        return false;
    }
    // Right must be a conditional whose test is `Object.setPrototypeOf`
    let Expr::Cond(cond) = strip_parens(&bin.right) else {
        return false;
    };
    let Expr::Member(m) = strip_parens(&cond.test) else {
        return false;
    };
    let Expr::Ident(obj_id) = m.obj.as_ref() else {
        return false;
    };
    is_unresolved_ident(obj_id, "Object", unresolved_mark)
        && matches!(&m.prop, MemberProp::Ident(n) if n.sym.as_ref() == "setPrototypeOf")
}

/// Check `if (typeof _super !== "function" && _super !== null) { throw ... }`.
/// Detect inline IIFE `_inherits` pattern:
/// ```js
/// ((e, t) => {
///     if (typeof t != "function" && t !== null) throw TypeError(...)
///     e.prototype = Object.create(t && t.prototype, { constructor: ... })
///     t && (Object.setPrototypeOf ? ... : ...)
/// })(ctor, super)
/// ```
fn is_inline_inherits_iife(
    stmt: &Stmt,
    ctor_name: &str,
    super_param: &str,
    unresolved_mark: Mark,
) -> bool {
    let Stmt::Expr(ExprStmt { expr, .. }) = stmt else {
        return false;
    };
    let Expr::Call(call) = expr.as_ref() else {
        return false;
    };
    let Callee::Expr(callee) = &call.callee else {
        return false;
    };

    // Must have 2 args: (ctor, super)
    if call.args.len() != 2 {
        return false;
    }
    let arg0 = strip_parens(&call.args[0].expr);
    let arg1 = strip_parens(&call.args[1].expr);
    if !matches!(arg0, Expr::Ident(id) if id.sym.as_ref() == ctor_name) {
        return false;
    }
    if !matches!(arg1, Expr::Ident(id) if id.sym.as_ref() == super_param) {
        return false;
    }

    // Callee must be an arrow or function with 2 params
    let inner = strip_parens(callee);
    let body_stmts: &[Stmt] = match inner {
        Expr::Arrow(arrow) => {
            if arrow.params.len() != 2 {
                return false;
            }
            match &*arrow.body {
                BlockStmtOrExpr::BlockStmt(block) => &block.stmts,
                _ => return false,
            }
        }
        Expr::Fn(fn_expr) => {
            if fn_expr.function.params.len() != 2 {
                return false;
            }
            match &fn_expr.function.body {
                Some(block) => &block.stmts,
                None => return false,
            }
        }
        _ => return false,
    };

    // Body should contain Object.create (prototype chain setup)
    body_stmts
        .iter()
        .any(|s| stmt_has_object_create(s, unresolved_mark))
}

/// Check if a statement contains `Object.create(...)` call.
fn stmt_has_object_create(stmt: &Stmt, unresolved_mark: Mark) -> bool {
    use swc_core::ecma::visit::{Visit, VisitWith};

    struct Finder {
        found: bool,
        unresolved_mark: Mark,
    }
    impl Visit for Finder {
        fn visit_call_expr(&mut self, call: &CallExpr) {
            if let Callee::Expr(callee) = &call.callee {
                if let Expr::Member(member) = callee.as_ref() {
                    if let Expr::Ident(obj) = member.obj.as_ref() {
                        if is_unresolved_ident(obj, "Object", self.unresolved_mark) {
                            if let MemberProp::Ident(prop) = &member.prop {
                                if prop.sym.as_ref() == "create" {
                                    self.found = true;
                                    return;
                                }
                            }
                        }
                    }
                }
            }
            call.visit_children_with(self);
        }
    }

    let mut finder = Finder {
        found: false,
        unresolved_mark,
    };
    stmt.visit_with(&mut finder);
    finder.found
}

fn is_super_typecheck_if_stmt(stmt: &Stmt, super_param: &str) -> bool {
    let Stmt::If(if_stmt) = stmt else {
        return false;
    };
    let Expr::Bin(bin) = strip_parens(&if_stmt.test) else {
        return false;
    };
    if bin.op != swc_core::ecma::ast::BinaryOp::LogicalAnd {
        return false;
    }
    is_typeof_not_function(strip_parens(&bin.left), super_param)
        && is_not_null_check(strip_parens(&bin.right), super_param)
}

/// Return true if `expr` is `typeof name !== "function"`.
fn is_typeof_not_function(expr: &Expr, name: &str) -> bool {
    let Expr::Bin(bin) = expr else {
        return false;
    };
    if bin.op != swc_core::ecma::ast::BinaryOp::NotEqEq {
        return false;
    }
    let Expr::Unary(u) = strip_parens(&bin.left) else {
        return false;
    };
    if u.op != swc_core::ecma::ast::UnaryOp::TypeOf {
        return false;
    }
    if !matches!(strip_parens(&u.arg), Expr::Ident(id) if id.sym.as_ref() == name) {
        return false;
    }
    matches!(
        strip_parens(&bin.right),
        Expr::Lit(swc_core::ecma::ast::Lit::Str(s)) if s.value.as_str() == Some("function")
    )
}

/// Return true if `expr` is `name !== null`.
fn is_not_null_check(expr: &Expr, name: &str) -> bool {
    let Expr::Bin(bin) = expr else {
        return false;
    };
    if bin.op != swc_core::ecma::ast::BinaryOp::NotEqEq {
        return false;
    }
    if !matches!(strip_parens(&bin.left), Expr::Ident(id) if id.sym.as_ref() == name) {
        return false;
    }
    matches!(
        strip_parens(&bin.right),
        Expr::Lit(swc_core::ecma::ast::Lit::Null(_))
    )
}

// ============================================================
// Builder helpers
// ============================================================

fn build_constructor(
    function: &Function,
    inner_ctor_name: &str,
    super_param: Option<&str>,
    call_super_helpers: &HashSet<BindingKey>,
    unresolved_mark: Mark,
) -> Option<Constructor> {
    let mut body = function.body.clone()?;
    let params: Vec<ParamOrTsParamProp> = function
        .params
        .iter()
        .map(|p| {
            ParamOrTsParamProp::Param(Param {
                span: DUMMY_SP,
                decorators: vec![],
                pat: p.pat.clone(),
            })
        })
        .collect();

    if let Some(sp) = super_param {
        // Unwrap inline _possibleConstructorReturn IIFEs before super rewriting
        unwrap_inline_pcr_iife(&mut body);
        // Rewrite `_callSuper(this, Ctor, args)` → `super(...args)` (Babel 7.24+)
        let mut call_super_rw = CallSuperRewriter {
            helpers: call_super_helpers,
            bailed: false,
        };
        body.visit_mut_with(&mut call_super_rw);
        if call_super_rw.bailed {
            return None;
        }
        // Rewrite `superParam.call(this, ...)` → `super(...)` in the constructor body
        body.visit_mut_with(&mut SuperCallRewriter {
            super_param_name: sp,
        });
        // Rewrite `(ctor.__proto__ || Object.getPrototypeOf(ctor)).apply(this, arguments)` → `super(...arguments)`
        // This pattern appears in inlined Babel classes where _inherits is baked in.
        body.visit_mut_with(&mut ProtoGetPrototypeOfSuperRewriter { unresolved_mark });
        // Simplify `super(...) || this` → `super(...)` — the `|| this` is dead code
        // per ES6 spec (super() always returns `this` in derived constructors)
        body.visit_mut_with(&mut SuperOrThisSimplifier);
        // Split `(alias = super(...)).prop = value` into `alias = super(...); alias.prop = value`
        // so that cleanup_super_aliases can detect the alias pattern.
        split_assign_prop_chains(&mut body);
        // Clean up super() aliases: in `n = r = super()`, both n and r are `this`.
        // Replace references with `this`, remove var decls and trailing `return alias`.
        cleanup_super_aliases(&mut body);
        remove_constructor_set_prototype_of_this(&mut body, inner_ctor_name, unresolved_mark);
        // Strip `return super(...)` → `super(...)` (constructors return implicitly)
        strip_return_super(&mut body);
    }

    let ctor_span = if function.span.lo.0 != 0 {
        function.span
    } else {
        DUMMY_SP
    };
    Some(Constructor {
        span: ctor_span,
        ctxt: Default::default(),
        key: PropName::Ident(IdentName::new("constructor".into(), DUMMY_SP)),
        params,
        body: Some(body),
        accessibility: None,
        is_optional: false,
    })
}

/// Detect and unwrap inline `_possibleConstructorReturn` IIFEs in constructor bodies.
///
/// Pattern:
/// ```js
/// return (function(e, t) {
///     if (!e) throw new ReferenceError("...");
///     return !t || ... ? e : t;
/// })(this, superCall);
/// ```
/// or the arrow variant: `((e, t) => { ... })(this, superCall)`
///
/// Replaced with: `return superCall`
fn unwrap_inline_pcr_iife(body: &mut BlockStmt) {
    for stmt in body.stmts.iter_mut() {
        // Handle `return pcrIIFE(this, expr)` → `return expr`
        if let Stmt::Return(ret) = stmt {
            if let Some(arg) = &mut ret.arg {
                if let Some(unwrapped) = try_unwrap_pcr_expr(arg) {
                    **arg = unwrapped;
                }
            }
        }
        // Handle `pcrIIFE(this, expr)` as expression statement → `expr`
        if let Stmt::Expr(ExprStmt { expr, .. }) = stmt {
            if let Some(unwrapped) = try_unwrap_pcr_expr(expr) {
                **expr = unwrapped;
            }
        }
    }
}

/// Try to unwrap an expression if it's an inline PCR IIFE call.
/// Also handles comma expressions like `classCallCheck(this, t), pcrIIFE(this, expr)`.
fn try_unwrap_pcr_expr(expr: &Expr) -> Option<Expr> {
    // Handle comma/sequence expression: `a, b` — check the last element
    if let Expr::Seq(seq) = expr {
        if let Some(last) = seq.exprs.last() {
            if let Some(unwrapped) = try_unwrap_pcr_call(last) {
                return Some(unwrapped);
            }
        }
        return None;
    }
    try_unwrap_pcr_call(expr)
}

/// Check if expr is an IIFE call matching the _possibleConstructorReturn body shape,
/// and return the second argument if so.
fn try_unwrap_pcr_call(expr: &Expr) -> Option<Expr> {
    let Expr::Call(call) = expr else { return None };
    let Callee::Expr(callee) = &call.callee else {
        return None;
    };
    let inner = strip_parens(callee);

    // Must have exactly 2 args: (this, superCall)
    if call.args.len() != 2 {
        return None;
    }
    // First arg must be `this`
    if !matches!(strip_parens(&call.args[0].expr), Expr::This(..)) {
        return None;
    }

    // Extract params and body from the callee (function or arrow)
    let (params, body_stmts): (Vec<&Pat>, &[Stmt]) = match inner {
        Expr::Fn(fn_expr) => {
            let body = fn_expr.function.body.as_ref()?;
            let pats: Vec<&Pat> = fn_expr.function.params.iter().map(|p| &p.pat).collect();
            (pats, &body.stmts)
        }
        Expr::Arrow(arrow) => {
            let BlockStmtOrExpr::BlockStmt(block) = &*arrow.body else {
                return None;
            };
            let pats: Vec<&Pat> = arrow.params.iter().collect();
            (pats, &block.stmts)
        }
        _ => return None,
    };

    // Must have 2 params
    if params.len() != 2 {
        return None;
    }
    let Pat::Ident(param1) = params[0] else {
        return None;
    };

    // First statement must be `if (!param1) throw new ReferenceError(...)`
    if body_stmts.is_empty() {
        return None;
    }
    if !is_pcr_guard_stmt(&body_stmts[0], &param1.id.sym) {
        return None;
    }

    // Matches! Return the second argument (the super call)
    Some(*call.args[1].expr.clone())
}

/// Check if a statement matches `if (!param) throw new ReferenceError(...)`.
/// Requires the throw to construct a `ReferenceError` specifically to avoid
/// false-positives on other guard-shaped inline functions.
fn is_pcr_guard_stmt(stmt: &Stmt, param_name: &str) -> bool {
    let Stmt::If(if_stmt) = stmt else {
        return false;
    };
    let Expr::Unary(unary) = if_stmt.test.as_ref() else {
        return false;
    };
    if unary.op != swc_core::ecma::ast::UnaryOp::Bang {
        return false;
    }
    if !matches!(strip_parens(&unary.arg), Expr::Ident(id) if id.sym.as_ref() == param_name) {
        return false;
    }
    // Consequent should throw ReferenceError (block or direct)
    let throw_expr = match if_stmt.cons.as_ref() {
        Stmt::Throw(t) => Some(&t.arg),
        Stmt::Block(block) if block.stmts.len() == 1 => {
            if let Stmt::Throw(t) = &block.stmts[0] {
                Some(&t.arg)
            } else {
                None
            }
        }
        _ => None,
    };
    let Some(throw_arg) = throw_expr else {
        return false;
    };
    is_new_reference_error(throw_arg)
}

/// Check if an expression is `new ReferenceError(...)`.
fn is_new_reference_error(expr: &Expr) -> bool {
    let Expr::New(new_expr) = strip_parens(expr) else {
        return false;
    };
    matches!(strip_parens(&new_expr.callee), Expr::Ident(id) if id.sym.as_ref() == "ReferenceError")
}

/// Strip `return super(...)` at the end of a constructor body → `super(...)` as expr stmt.
/// In derived constructors, `return super()` is unnecessary; super() implicitly returns this.
fn strip_return_super(body: &mut BlockStmt) {
    if let Some(Stmt::Return(ret)) = body.stmts.last() {
        if let Some(arg) = &ret.arg {
            if is_super_call(arg) {
                let super_call = arg.clone();
                let len = body.stmts.len();
                body.stmts[len - 1] = Stmt::Expr(ExprStmt {
                    span: DUMMY_SP,
                    expr: super_call,
                });
            }
        }
    }
}

/// Split `(alias = super(...)).prop = value` into two statements:
///   `alias = super(...);`
///   `alias.prop = value;`
///
/// Babel minifiers produce `(o = super()).x = 1, o.y = 2, ...` where the assignment
/// and property access are fused. Splitting allows `cleanup_super_aliases` to detect
/// the alias and replace `o.x` with `this.x`.
fn split_assign_prop_chains(body: &mut BlockStmt) {
    let mut new_stmts = Vec::with_capacity(body.stmts.len());
    for stmt in std::mem::take(&mut body.stmts) {
        if let Stmt::Expr(ExprStmt { expr, span }) = &stmt {
            if let Some((assign_stmt, prop_stmt)) = try_split_assign_prop(expr, *span) {
                new_stmts.push(assign_stmt);
                new_stmts.push(prop_stmt);
                continue;
            }
        }
        new_stmts.push(stmt);
    }
    body.stmts = new_stmts;
}

/// Try to split `(alias = super(...)).prop = value` into two statements.
fn try_split_assign_prop(expr: &Expr, span: swc_core::common::Span) -> Option<(Stmt, Stmt)> {
    let Expr::Assign(outer) = expr else {
        return None;
    };
    if outer.op != AssignOp::Assign {
        return None;
    }

    // LHS must be a member expression whose object is a paren-wrapped assignment
    let AssignTarget::Simple(SimpleAssignTarget::Member(member)) = &outer.left else {
        return None;
    };

    let obj = strip_parens(&member.obj);
    let Expr::Assign(inner) = obj else {
        return None;
    };
    if inner.op != AssignOp::Assign {
        return None;
    }

    // The inner RHS must be a super call
    if !is_super_call(&inner.right) {
        return None;
    }

    // Extract the alias ident
    let AssignTarget::Simple(SimpleAssignTarget::Ident(alias)) = &inner.left else {
        return None;
    };

    // Statement 1: alias = super(...)
    let assign_stmt = Stmt::Expr(ExprStmt {
        span,
        expr: Box::new(Expr::Assign(AssignExpr {
            span: DUMMY_SP,
            op: AssignOp::Assign,
            left: inner.left.clone(),
            right: inner.right.clone(),
        })),
    });

    // Statement 2: alias.prop = value
    let prop_stmt = Stmt::Expr(ExprStmt {
        span,
        expr: Box::new(Expr::Assign(AssignExpr {
            span: DUMMY_SP,
            op: outer.op,
            left: AssignTarget::Simple(SimpleAssignTarget::Member(MemberExpr {
                span: DUMMY_SP,
                obj: Box::new(Expr::Ident(Ident::new(
                    alias.sym.clone(),
                    DUMMY_SP,
                    alias.ctxt,
                ))),
                prop: member.prop.clone(),
            })),
            right: outer.right.clone(),
        })),
    });

    Some((assign_stmt, prop_stmt))
}

/// Simplifies `super(...) || this` → `super(...)` in constructor bodies.
/// In ES6, super() in a derived constructor always returns `this`, so the
/// `|| this` fallback is dead code. Removing it allows cleanup_super_aliases
/// to recognize the pattern.
struct SuperOrThisSimplifier;

impl VisitMut for SuperOrThisSimplifier {
    fn visit_mut_expr(&mut self, expr: &mut Expr) {
        expr.visit_mut_children_with(self);

        let Expr::Bin(bin) = expr else { return };
        if bin.op != swc_core::ecma::ast::BinaryOp::LogicalOr {
            return;
        }
        if !is_super_call(&bin.left) {
            return;
        }
        if !matches!(*bin.right, Expr::This(..)) {
            return;
        }
        // Replace `super(...) || this` with just `super(...)`
        *expr = *bin.left.take();
    }

    // Don't descend into nested functions/arrows
    fn visit_mut_function(&mut self, _: &mut Function) {}
    fn visit_mut_arrow_expr(&mut self, _: &mut ArrowExpr) {}
}

/// Rewrites `superParam.call(this, args...)` → `super(args...)`
/// and `superParam.apply(this, arguments)` → `super(...arguments)` in constructor bodies.
struct SuperCallRewriter<'a> {
    super_param_name: &'a str,
}

impl VisitMut for SuperCallRewriter<'_> {
    fn visit_mut_expr(&mut self, expr: &mut Expr) {
        expr.visit_mut_children_with(self);

        let Expr::Call(call) = expr else { return };
        let Callee::Expr(callee) = &call.callee else {
            return;
        };
        let Expr::Member(member) = callee.as_ref() else {
            return;
        };

        // Check: superParam.call or superParam.apply
        let Expr::Ident(obj_id) = member.obj.as_ref() else {
            return;
        };
        if obj_id.sym.as_ref() != self.super_param_name {
            return;
        }
        let MemberProp::Ident(prop) = &member.prop else {
            return;
        };

        match prop.sym.as_ref() {
            "call" => {
                // Must have at least 1 arg (the `this` arg)
                if call.args.is_empty() {
                    return;
                }
                // First arg should be `this` — skip it, rest become super() args
                if !matches!(call.args[0].expr.as_ref(), Expr::This(..)) {
                    return;
                }
                let super_args: Vec<ExprOrSpread> = call.args[1..].to_vec();
                *expr = Expr::Call(CallExpr {
                    span: DUMMY_SP,
                    ctxt: Default::default(),
                    callee: Callee::Super(swc_core::ecma::ast::Super { span: DUMMY_SP }),
                    args: super_args,
                    type_args: None,
                });
            }
            "apply" => {
                // e.apply(this, arguments) → super(...arguments)
                // Only handle when second arg is `arguments` — other values like
                // null/undefined have different semantics with .apply vs spread.
                if call.args.len() != 2 {
                    return;
                }
                if !matches!(call.args[0].expr.as_ref(), Expr::This(..)) {
                    return;
                }
                // Second arg must be `arguments` or an array literal for safe conversion
                let second = strip_parens(&call.args[1].expr);
                let is_safe = matches!(second, Expr::Ident(id) if id.sym.as_ref() == "arguments")
                    || matches!(second, Expr::Array(_));
                if !is_safe {
                    return;
                }
                // Second arg becomes a spread argument to super()
                let spread_arg = ExprOrSpread {
                    spread: Some(DUMMY_SP),
                    expr: call.args[1].expr.take(),
                };
                *expr = Expr::Call(CallExpr {
                    span: DUMMY_SP,
                    ctxt: Default::default(),
                    callee: Callee::Super(swc_core::ecma::ast::Super { span: DUMMY_SP }),
                    args: vec![spread_arg],
                    type_args: None,
                });
            }
            _ => {}
        }
    }

    fn visit_mut_function(&mut self, _: &mut Function) {}

    fn visit_mut_arrow_expr(&mut self, _: &mut ArrowExpr) {}

    fn visit_mut_class(&mut self, _: &mut Class) {}
}

/// Rewrite `_callSuper(this, Ctor, args)` → `super(...args)` (Babel 7.24+ helper).
///
/// Handles:
/// - `_callSuper(this, Foo, arguments)` → `super(...arguments)`
/// - `_callSuper(this, Foo, [a, b])` → `super(a, b)`
/// - `_callSuper(this, Foo)` → `super()`
///
/// Sets `bailed = true` if a call is detected but cannot be safely rewritten.
struct CallSuperRewriter<'a> {
    helpers: &'a HashSet<BindingKey>,
    bailed: bool,
}

impl VisitMut for CallSuperRewriter<'_> {
    fn visit_mut_expr(&mut self, expr: &mut Expr) {
        expr.visit_mut_children_with(self);

        let Expr::Call(call) = expr else { return };
        let Callee::Expr(callee) = &call.callee else {
            return;
        };
        let Expr::Ident(fn_name) = strip_parens(callee) else {
            return;
        };
        if !self.helpers.contains(&binding_key(fn_name)) {
            return;
        }
        // _callSuper(this, Ctor) or _callSuper(this, Ctor, argsExpr)
        if call.args.len() < 2 || call.args.len() > 3 {
            return;
        }
        // First arg must be `this`
        if !matches!(strip_parens(&call.args[0].expr), Expr::This(..)) {
            return;
        }

        let super_args = if call.args.len() == 3 {
            let third = strip_parens(&call.args[2].expr);
            match third {
                // _callSuper(this, Foo, arguments) → super(...arguments)
                Expr::Ident(id) if id.sym.as_ref() == "arguments" => {
                    vec![ExprOrSpread {
                        spread: Some(DUMMY_SP),
                        expr: call.args[2].expr.take(),
                    }]
                }
                // _callSuper(this, Foo, [a, b]) → super(a, b)
                Expr::Array(arr) => arr
                    .elems
                    .iter()
                    .filter_map(|e| {
                        e.as_ref().map(|el| ExprOrSpread {
                            spread: el.spread,
                            expr: el.expr.clone(),
                        })
                    })
                    .collect(),
                // Unknown expression — unsafe to spread (Babel does `e || []`)
                _ => {
                    self.bailed = true;
                    return;
                }
            }
        } else {
            // _callSuper(this, Foo) → super()
            vec![]
        };

        *expr = Expr::Call(CallExpr {
            span: DUMMY_SP,
            ctxt: Default::default(),
            callee: Callee::Super(swc_core::ecma::ast::Super { span: DUMMY_SP }),
            args: super_args,
            type_args: None,
        });
    }

    fn visit_mut_function(&mut self, _: &mut Function) {}
    fn visit_mut_arrow_expr(&mut self, _: &mut ArrowExpr) {}
    fn visit_mut_class(&mut self, _: &mut Class) {}
}

/// Rewrite `(X.__proto__ || Object.getPrototypeOf(X)).apply(this, arguments)` → `super(...arguments)`
/// and `(X.__proto__ || Object.getPrototypeOf(X)).call(this, ...)` → `super(...)`
///
/// This pattern appears in inlined Babel classes where `_inherits` is called inline
/// rather than via a separate helper function.
struct ProtoGetPrototypeOfSuperRewriter {
    unresolved_mark: Mark,
}

impl VisitMut for ProtoGetPrototypeOfSuperRewriter {
    fn visit_mut_expr(&mut self, expr: &mut Expr) {
        expr.visit_mut_children_with(self);

        let Expr::Call(call) = expr else { return };
        let Callee::Expr(callee) = &call.callee else {
            return;
        };
        let Expr::Member(member) = callee.as_ref() else {
            return;
        };
        let MemberProp::Ident(prop) = &member.prop else {
            return;
        };

        // Object must be `(X.__proto__ || Object.getPrototypeOf(X))`
        if !is_proto_or_get_prototype_of(strip_parens(&member.obj), self.unresolved_mark) {
            return;
        }

        match prop.sym.as_ref() {
            "apply" => {
                if call.args.len() != 2 {
                    return;
                }
                if !matches!(call.args[0].expr.as_ref(), Expr::This(..)) {
                    return;
                }
                let second = strip_parens(&call.args[1].expr);
                let is_safe = matches!(second, Expr::Ident(id) if id.sym.as_ref() == "arguments")
                    || matches!(second, Expr::Array(_));
                if !is_safe {
                    return;
                }
                let spread_arg = ExprOrSpread {
                    spread: Some(DUMMY_SP),
                    expr: call.args[1].expr.take(),
                };
                *expr = Expr::Call(CallExpr {
                    span: DUMMY_SP,
                    ctxt: Default::default(),
                    callee: Callee::Super(swc_core::ecma::ast::Super { span: DUMMY_SP }),
                    args: vec![spread_arg],
                    type_args: None,
                });
            }
            "call" => {
                if call.args.is_empty() {
                    return;
                }
                if !matches!(call.args[0].expr.as_ref(), Expr::This(..)) {
                    return;
                }
                let super_args: Vec<ExprOrSpread> = call.args[1..].to_vec();
                *expr = Expr::Call(CallExpr {
                    span: DUMMY_SP,
                    ctxt: Default::default(),
                    callee: Callee::Super(swc_core::ecma::ast::Super { span: DUMMY_SP }),
                    args: super_args,
                    type_args: None,
                });
            }
            _ => {}
        }
    }
}

/// Check if an expression is `(X.__proto__ || Object.getPrototypeOf(X))`.
fn is_proto_or_get_prototype_of(expr: &Expr, unresolved_mark: Mark) -> bool {
    match expr {
        Expr::Bin(bin) if bin.op == swc_core::ecma::ast::BinaryOp::LogicalOr => {
            // Left: `X.__proto__`
            if let Expr::Member(m) = strip_parens(&bin.left) {
                if let MemberProp::Ident(p) = &m.prop {
                    if p.sym.as_ref() == "__proto__" {
                        return true;
                    }
                }
            }
            false
        }
        Expr::Call(call) => {
            // `Object.getPrototypeOf(X)`
            if let Callee::Expr(callee) = &call.callee {
                if let Expr::Member(m) = callee.as_ref() {
                    if let (Expr::Ident(obj), MemberProp::Ident(prop)) = (m.obj.as_ref(), &m.prop) {
                        return is_unresolved_ident(obj, "Object", unresolved_mark)
                            && prop.sym.as_ref() == "getPrototypeOf";
                    }
                }
            }
            false
        }
        _ => false,
    }
}

/// In a derived constructor, `super()` returns `this`. Clean up:
/// - `var r = super(...)` → `super(...)`; mark `r` as this-alias
/// - `n = r = super(...)` → `super(...)`; mark both as this-aliases
/// - Replace all references to aliases with `this`
/// - Remove `var` declarations for aliases
/// - Remove trailing `return alias`
fn cleanup_super_aliases(body: &mut BlockStmt) {
    use std::collections::HashSet;

    let mut aliases: HashSet<Atom> = HashSet::new();

    // Pass 1: Find super() call statements and collect aliases
    for stmt in body.stmts.iter_mut() {
        // Pattern: `var r = super(...)` as a var decl
        if let Stmt::Decl(Decl::Var(var)) = stmt {
            for decl in &var.decls {
                if let (Pat::Ident(bi), Some(init)) = (&decl.name, &decl.init) {
                    if is_super_call(init) {
                        aliases.insert(bi.id.sym.clone());
                    }
                }
            }
        }

        // Pattern: `n = r = super(...)` or `r = super(...)` as expr stmt
        if let Stmt::Expr(ExprStmt { expr, .. }) = stmt {
            collect_assign_chain_aliases(expr, &mut aliases);
        }
    }

    if aliases.is_empty() {
        return;
    }

    // Pass 2: Rewrite alias references → `this`
    body.visit_mut_with(&mut AliasToThisRewriter { aliases: &aliases });

    // Pass 3: Rewrite statements — remove alias decls, simplify assign chains,
    // replace alias references with `this`, remove trailing `return alias`.
    let mut new_stmts = Vec::with_capacity(body.stmts.len());
    for stmt in std::mem::take(&mut body.stmts) {
        match stmt {
            // `var n;` (bare alias) → drop
            // `var r = super(...)` → keep `super(...)` as expr stmt
            Stmt::Decl(Decl::Var(mut var)) => {
                let mut keep_decls = Vec::new();
                for d in std::mem::take(&mut var.decls) {
                    let Pat::Ident(ref bi) = d.name else {
                        keep_decls.push(d);
                        continue;
                    };
                    if !aliases.contains(&bi.id.sym) {
                        keep_decls.push(d);
                        continue;
                    }
                    // Alias decl: extract super() call as statement if present
                    if let Some(init) = &d.init {
                        if is_super_call(init) {
                            new_stmts.push(Stmt::Expr(ExprStmt {
                                span: DUMMY_SP,
                                expr: init.clone(),
                            }));
                        }
                    }
                    // Drop the var declarator
                }
                if !keep_decls.is_empty() {
                    var.decls = keep_decls;
                    new_stmts.push(Stmt::Decl(Decl::Var(var)));
                }
            }
            // `n = r = super(...)` → `super(...)`
            Stmt::Expr(ExprStmt { ref expr, span }) => {
                if let Some(super_call) = extract_super_from_assign_chain(expr, &aliases) {
                    new_stmts.push(Stmt::Expr(ExprStmt {
                        expr: Box::new(super_call),
                        span,
                    }));
                } else {
                    new_stmts.push(stmt);
                }
            }
            // `return alias` → drop (constructor implicitly returns this)
            Stmt::Return(ref ret) => {
                let should_drop = ret.arg.as_ref().is_some_and(|arg| {
                    matches!(arg.as_ref(), Expr::Ident(id) if aliases.contains(&id.sym))
                        || matches!(arg.as_ref(), Expr::This(..))
                });
                if !should_drop {
                    new_stmts.push(stmt);
                }
            }
            other => new_stmts.push(other),
        }
    }
    body.stmts = new_stmts;
}

fn remove_constructor_set_prototype_of_this(
    body: &mut BlockStmt,
    inner_ctor_name: &str,
    unresolved_mark: Mark,
) {
    body.stmts.retain(|stmt| {
        !matches!(
            stmt,
            Stmt::Expr(ExprStmt { expr, .. })
                if is_set_prototype_of_this_to_ctor_prototype(
                    expr,
                    inner_ctor_name,
                    unresolved_mark,
                )
        )
    });
}

fn is_set_prototype_of_this_to_ctor_prototype(
    expr: &Expr,
    inner_ctor_name: &str,
    unresolved_mark: Mark,
) -> bool {
    let Expr::Call(call) = strip_parens(expr) else {
        return false;
    };
    let Callee::Expr(callee) = &call.callee else {
        return false;
    };
    if !is_object_set_prototype_of(callee, unresolved_mark) {
        return false;
    }
    if call.args.len() != 2 || call.args.iter().any(|arg| arg.spread.is_some()) {
        return false;
    }
    if !matches!(strip_parens(&call.args[0].expr), Expr::This(..)) {
        return false;
    }
    is_ctor_prototype_expr(&call.args[1].expr, inner_ctor_name)
}

fn is_object_set_prototype_of(expr: &Expr, unresolved_mark: Mark) -> bool {
    let Expr::Member(member) = strip_parens(expr) else {
        return false;
    };
    let Expr::Ident(obj) = member.obj.as_ref() else {
        return false;
    };
    is_unresolved_ident(obj, "Object", unresolved_mark)
        && matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "setPrototypeOf")
}

fn is_ctor_prototype_expr(expr: &Expr, inner_ctor_name: &str) -> bool {
    let Expr::Member(member) = strip_parens(expr) else {
        return false;
    };
    let Expr::Ident(obj) = member.obj.as_ref() else {
        return false;
    };
    obj.sym.as_ref() == inner_ctor_name
        && matches!(&member.prop, MemberProp::Ident(prop) if prop.sym.as_ref() == "prototype")
}

fn is_super_call(expr: &Expr) -> bool {
    matches!(expr, Expr::Call(call) if matches!(call.callee, Callee::Super(..)))
}

/// Walk an assignment chain like `n = r = super()` and collect all LHS idents as aliases.
fn collect_assign_chain_aliases(expr: &Expr, aliases: &mut std::collections::HashSet<Atom>) {
    let Expr::Assign(assign) = expr else { return };
    if assign.op != AssignOp::Assign {
        return;
    }

    // Check if the RHS is super() or another assignment chain ending in super()
    let rhs_is_super = is_super_call(&assign.right)
        || matches!(assign.right.as_ref(), Expr::Assign(_) if {
            let mut inner_aliases = std::collections::HashSet::new();
            collect_assign_chain_aliases(&assign.right, &mut inner_aliases);
            !inner_aliases.is_empty()
        });

    if rhs_is_super {
        if let AssignTarget::Simple(SimpleAssignTarget::Ident(id)) = &assign.left {
            aliases.insert(id.sym.clone());
        }
        // Recurse into RHS for chained assigns
        collect_assign_chain_aliases(&assign.right, aliases);
    }
}

/// Extract the super() call from an assignment chain like `n = r = super(...)`.
/// Returns Some(super_call_expr) if all LHS idents are known aliases, None otherwise.
fn extract_super_from_assign_chain(
    expr: &Expr,
    aliases: &std::collections::HashSet<Atom>,
) -> Option<Expr> {
    let Expr::Assign(assign) = expr else {
        return None;
    };
    if assign.op != AssignOp::Assign {
        return None;
    }

    // LHS must be an alias
    let is_alias_lhs = matches!(
        &assign.left,
        AssignTarget::Simple(SimpleAssignTarget::Ident(id)) if aliases.contains(&id.sym)
    );
    if !is_alias_lhs {
        return None;
    }

    // RHS is super() → return super()
    if is_super_call(&assign.right) {
        return Some(*assign.right.clone());
    }

    // RHS is another alias = super() chain → recurse
    extract_super_from_assign_chain(&assign.right, aliases)
}

struct AliasToThisRewriter<'a> {
    aliases: &'a std::collections::HashSet<Atom>,
}

impl VisitMut for AliasToThisRewriter<'_> {
    fn visit_mut_expr(&mut self, expr: &mut Expr) {
        expr.visit_mut_children_with(self);

        if let Expr::Ident(id) = expr {
            if self.aliases.contains(&id.sym) {
                *expr = Expr::This(swc_core::ecma::ast::ThisExpr { span: DUMMY_SP });
            }
        }
    }

    // Don't descend into nested functions/arrows
    fn visit_mut_function(&mut self, _: &mut Function) {}
    fn visit_mut_arrow_expr(&mut self, _: &mut ArrowExpr) {}
}

/// Returns true if the constructor is empty or is the default derived constructor
/// (`constructor() { super(...arguments); }` or `constructor(...args) { super(...args); }`).
/// These are equivalent to omitting the constructor entirely.
fn is_default_constructor(ctor: &Constructor) -> bool {
    let Some(body) = &ctor.body else { return true };
    if body.stmts.is_empty() {
        return true;
    }
    // Must have no parameters (Babel default ctor pattern uses `arguments`)
    // OR a single rest parameter that matches the super call's spread arg
    if body.stmts.len() != 1 {
        return false;
    }
    let Stmt::Expr(ExprStmt { expr, .. }) = &body.stmts[0] else {
        return false;
    };
    let Expr::Call(call) = expr.as_ref() else {
        return false;
    };
    // Must be super(...)
    if !matches!(&call.callee, Callee::Super(_)) {
        return false;
    }
    // super() with no params — default for parameterless constructors
    if call.args.is_empty() && ctor.params.is_empty() {
        return true;
    }
    // super(...arguments) with no declared params
    if call.args.len() == 1 && ctor.params.is_empty() {
        let arg = &call.args[0];
        if arg.spread.is_some() {
            if let Expr::Ident(id) = arg.expr.as_ref() {
                return id.sym.as_ref() == "arguments";
            }
        }
    }
    // constructor(...args) { super(...args); } — rest param forwarded to super
    if call.args.len() == 1 && ctor.params.len() == 1 {
        let arg = &call.args[0];
        if arg.spread.is_some() {
            if let Expr::Ident(arg_id) = arg.expr.as_ref() {
                if let ParamOrTsParamProp::Param(param) = &ctor.params[0] {
                    if let Pat::Rest(rest) = &param.pat {
                        if let Pat::Ident(bind) = rest.arg.as_ref() {
                            return bind.id.sym == arg_id.sym;
                        }
                    }
                }
            }
        }
    }
    false
}

fn build_class_method(
    key: PropName,
    fn_expr: &FnExpr,
    is_static: bool,
    kind: MethodKind,
) -> ClassMethod {
    let method_span = if fn_expr.function.span.lo.0 != 0 {
        fn_expr.function.span
    } else {
        DUMMY_SP
    };
    ClassMethod {
        span: method_span,
        key,
        function: fn_expr.function.clone(),
        kind,
        is_static,
        accessibility: None,
        is_abstract: false,
        is_optional: false,
        is_override: false,
    }
}