crates/core/src/driver/unpack/mod.rs

GitHub
use anyhow::{anyhow, Result};
use rayon::prelude::*;
use swc_core::common::{sync::Lrc, Mark, SourceMap, GLOBALS};
use swc_core::ecma::ast::Module;
use swc_core::ecma::transforms::base::resolver;
use swc_core::ecma::visit::VisitMutWith;

use super::io::{apply_fixer, parse_js, print_js};
use super::single_file::decompile;
use super::types::{
    DecompileOptions, ModuleProvenance, UnpackInput, UnpackOutput, UnpackWarning, UnpackWarningKind,
};
#[cfg(test)]
use super::unpack_cleanup::hoist_late_runtime_helpers;
use super::unpack_cycles::merge_import_cycles;
#[cfg(test)]
use super::unpack_cycles::{
    collect_import_cycle_warnings, scan_local_import_dependencies, unsafe_merge_member_reason,
};
use crate::rules::{
    apply_rules, ArrowFunction, ArrowReturn, RewriteLevel, RulePipelineOptions, SmartRename, UnEsm,
    UnExportRename, UnIife,
};
use crate::unpacker::{
    scope_hoist, try_unpack_bundle, webpack5, BundleFormat, UnpackResult, UnpackedModule,
};

mod dead_module;
mod filename_recovery;
mod merge;
mod phases;
mod scope_split;

use merge::{
    emit_raw_modules_with_numeric_rewrites, prepare_multi_source_modules, MultiSourceModule,
    NumericRewritePlan, PreparedUnpackModule,
};
#[cfg(test)]
use phases::unpack_multi_module;
use phases::unpack_multi_module_with_plan;
use scope_split::maybe_split_scope_hoisted_modules;

pub fn unpack(source: &str, options: DecompileOptions) -> Result<UnpackOutput> {
    let span = tracing::info_span!("unpack");
    let _enter = span.enter();

    match detect_bundle(source, &options.filename)? {
        Some(result) => {
            let format = result.format;
            let result =
                maybe_split_scope_hoisted_modules(result, nested_scope_split_enabled(&options));
            let mut output = unpack_unpack_result(result, options)?;
            output.detected_formats.push(format);
            Ok(output)
        }
        None if options.heuristic_split => match scope_hoist::split_scope_hoisted(source) {
            Some(result) if result.modules.len() > 1 => {
                let mut opts = options.clone();
                opts.dce_mode = super::types::DceMode::Off;
                let mut output = unpack_unpack_result(result, opts)?;
                output.detected_formats.push(BundleFormat::ScopeHoisted);
                Ok(output)
            }
            _ => {
                let output = decompile(source, options)?;
                let source_maps = output
                    .source_map
                    .map(|m| vec![("module.js".to_string(), m)])
                    .unwrap_or_default();
                Ok(UnpackOutput {
                    modules: vec![("module.js".to_string(), output.code)],
                    provenance: vec![whole_input_provenance("module.js", "", source)],
                    warnings: output.warnings,
                    detected_formats: Vec::new(),
                    source_maps,
                })
            }
        },
        None => {
            let output = decompile(source, options)?;
            let source_maps = output
                .source_map
                .map(|m| vec![("module.js".to_string(), m)])
                .unwrap_or_default();
            Ok(UnpackOutput {
                modules: vec![("module.js".to_string(), output.code)],
                provenance: vec![whole_input_provenance("module.js", "", source)],
                warnings: output.warnings,
                detected_formats: Vec::new(),
                source_maps,
            })
        }
    }
}

pub fn unpack_files(
    mut inputs: Vec<UnpackInput>,
    mut options: DecompileOptions,
) -> Result<UnpackOutput> {
    if inputs.is_empty() {
        return Err(anyhow!("at least one input file is required"));
    }

    if inputs.len() == 1 {
        let input = inputs.pop().expect("checked input length");
        options.filename = input.filename;
        return unpack(&input.source, options);
    }

    let span = tracing::info_span!("unpack_files", count = inputs.len());
    let _enter = span.enter();

    let mut modules = Vec::new();
    let mut detected_formats = Vec::new();
    for input in inputs {
        match detect_bundle(&input.source, &input.filename)? {
            Some(result) => {
                let format = result.format;
                if !detected_formats.contains(&format) {
                    detected_formats.push(format);
                }
                let result =
                    maybe_split_scope_hoisted_modules(result, nested_scope_split_enabled(&options));
                let chunk_ids = webpack5::detect_chunk_ids(&input.source);
                let input_filename = input.filename.clone();
                let allow_cycle_premerge = result.allow_cycle_premerge;
                modules.extend(result.modules.into_iter().map(|module| {
                    MultiSourceModule::detected(
                        module,
                        chunk_ids.clone(),
                        input_filename.clone(),
                        allow_cycle_premerge,
                    )
                }))
            }
            None if options.heuristic_split => {
                match scope_hoist::split_scope_hoisted(&input.source) {
                    Some(result) if result.modules.len() > 1 => {
                        if !detected_formats.contains(&BundleFormat::ScopeHoisted) {
                            detected_formats.push(BundleFormat::ScopeHoisted);
                        }
                        modules.extend(result.modules.into_iter().map(|mut module| {
                            module.source_input = input.filename.clone();
                            MultiSourceModule::fallback(module)
                        }))
                    }
                    _ => modules.push(MultiSourceModule::fallback(
                        crate::unpacker::UnpackedModule {
                            id: input.filename.clone(),
                            is_entry: false,
                            filename: filename_for_fallback_input(&input.filename),
                            source_ranges: vec![(0, input.source.len() as u32)],
                            source_input: input.filename.clone(),
                            generated_source_map: Vec::new(),
                            code: input.source,
                        },
                    )),
                }
            }
            None => modules.push(MultiSourceModule::fallback(
                crate::unpacker::UnpackedModule {
                    id: input.filename.clone(),
                    is_entry: false,
                    filename: filename_for_fallback_input(&input.filename),
                    source_ranges: vec![(0, input.source.len() as u32)],
                    source_input: input.filename.clone(),
                    generated_source_map: Vec::new(),
                    code: input.source,
                },
            )),
        }
    }

    if modules.is_empty() {
        return Err(anyhow!("no modules were extracted from input files"));
    }

    let (modules, numeric_rewrite_plan) = prepare_multi_source_modules(modules);
    let mut output = unpack_multi_module_with_plan(modules, numeric_rewrite_plan, options)?;
    output.detected_formats = detected_formats;
    Ok(output)
}

/// Unpack a bundle without running the decompiler rule pipeline.
///
/// This returns raw module output after detector-specific extraction and
/// bundler-coupled normalization. Cross-module analysis and the normal
/// decompile rule pipeline are skipped.
pub fn unpack_raw(source: &str, options: &DecompileOptions) -> Result<UnpackOutput> {
    let result = detect_bundle_raw(source, &options.filename)?
        .map(|result| {
            let format = result.format;
            (
                maybe_split_scope_hoisted_modules(result, nested_scope_split_enabled(options)),
                false,
                format,
            )
        })
        .or_else(|| {
            if options.heuristic_split {
                let r = scope_hoist::split_scope_hoisted(source)?;
                if r.modules.len() > 1 {
                    Some((r, true, BundleFormat::ScopeHoisted))
                } else {
                    None
                }
            } else {
                None
            }
        });
    match result {
        Some((result, normalize_for_runnable_split, format)) => {
            let (modules, provenance, warnings) = if normalize_for_runnable_split {
                // Heuristic scope-hoisted fallback does not get the esbuild
                // detector's bundler-specific cleanup, so keep the narrow
                // runnable normalization it still relies on.
                let (modules, warnings) = {
                    if should_merge_raw_import_cycles(&result.modules) {
                        let span = tracing::info_span!("raw_merge_import_cycles");
                        let _enter = span.enter();
                        merge_import_cycles(result.modules)
                    } else {
                        (result.modules, Vec::new())
                    }
                };
                let provenance = module_provenance(&modules);
                let normalized: Vec<_> = modules
                    .into_par_iter()
                    .map(|module| {
                        match normalize_raw_unpacked_module(&module.code, &module.filename) {
                            Ok(normalized) => ((module.filename, normalized), None),
                            Err(e) => {
                                let warning = UnpackWarning::new(
                                    module.filename.clone(),
                                    UnpackWarningKind::RawNormalizationFailed,
                                    format!(
                                        "raw normalization failed, preserving unparsed code: {e}"
                                    ),
                                );
                                ((module.filename, module.code), Some(warning))
                            }
                        }
                    })
                    .collect();
                let mut output_modules = Vec::with_capacity(normalized.len());
                let mut output_warnings = if options.diagnostics {
                    warnings
                } else {
                    Vec::new()
                };
                for (module, warning) in normalized {
                    if options.diagnostics {
                        if let Some(warning) = warning {
                            output_warnings.push(warning);
                        }
                    }
                    output_modules.push(module);
                }
                (output_modules, provenance, output_warnings)
            } else {
                let provenance = module_provenance(&result.modules);
                (
                    result
                        .modules
                        .into_iter()
                        .map(|module| (module.filename, module.code))
                        .collect(),
                    provenance,
                    Vec::new(),
                )
            };
            Ok(UnpackOutput {
                modules,
                provenance,
                warnings,
                detected_formats: vec![format],
                source_maps: Vec::new(),
            })
        }
        None => Ok(UnpackOutput {
            modules: vec![("module.js".to_string(), source.to_string())],
            provenance: vec![whole_input_provenance("module.js", "", source)],
            warnings: Vec::new(),
            detected_formats: Vec::new(),
            source_maps: Vec::new(),
        }),
    }
}

fn nested_scope_split_enabled(options: &DecompileOptions) -> bool {
    options.heuristic_split && options.level == RewriteLevel::Aggressive
}

pub fn unpack_files_raw(
    mut inputs: Vec<UnpackInput>,
    options: &DecompileOptions,
) -> Result<UnpackOutput> {
    if inputs.is_empty() {
        return Err(anyhow!("at least one input file is required"));
    }

    if inputs.len() == 1 {
        let input = inputs.pop().expect("checked input length");
        let mut opts = options.clone();
        opts.filename = input.filename;
        return unpack_raw(&input.source, &opts);
    }

    let mut modules = Vec::new();
    let mut detected_formats = Vec::new();

    for input in inputs {
        let result = detect_bundle_raw(&input.source, &input.filename)?.or_else(|| {
            if options.heuristic_split {
                let r = scope_hoist::split_scope_hoisted(&input.source)?;
                if r.modules.len() > 1 {
                    Some(r)
                } else {
                    None
                }
            } else {
                None
            }
        });

        match result {
            Some(result) => {
                let format = result.format;
                if !detected_formats.contains(&format) {
                    detected_formats.push(format);
                }
                let result =
                    maybe_split_scope_hoisted_modules(result, nested_scope_split_enabled(options));
                let chunk_ids = webpack5::detect_chunk_ids(&input.source);
                let allow_cycle_premerge = result.allow_cycle_premerge;
                modules.extend(result.modules.into_iter().map(|module| {
                    MultiSourceModule::detected(
                        module,
                        chunk_ids.clone(),
                        input.filename.clone(),
                        allow_cycle_premerge,
                    )
                }));
            }
            None => modules.push(MultiSourceModule::fallback(UnpackedModule {
                id: input.filename.clone(),
                is_entry: false,
                filename: filename_for_fallback_input(&input.filename),
                source_ranges: vec![(0, input.source.len() as u32)],
                source_input: input.filename.clone(),
                generated_source_map: Vec::new(),
                code: input.source.to_string(),
            })),
        }
    }

    let (modules, numeric_rewrite_plan) = prepare_multi_source_modules(modules);
    let mut output = emit_raw_modules_with_numeric_rewrites(modules, numeric_rewrite_plan)?;
    output.detected_formats = detected_formats;
    Ok(output)
}

fn filename_for_fallback_input(filename: &str) -> String {
    let path = std::path::Path::new(filename);
    path.file_name()
        .and_then(|name| name.to_str())
        .filter(|name| !name.is_empty())
        .unwrap_or("module.js")
        .to_string()
}

pub(super) fn detect_bundle(source: &str, filename: &str) -> Result<Option<UnpackResult>> {
    let span = tracing::info_span!("detect_bundle");
    let _enter = span.enter();

    match try_unpack_bundle(source) {
        Ok(result) => Ok(result),
        Err(bundle_parse_error) => {
            // Bundle detection intentionally parses only ES/JSX. Preserve the
            // single-file fallback for valid inputs that use filename-driven
            // syntax such as TypeScript. That means a second parse here is
            // intentional: it distinguishes unsupported bundle syntax from
            // genuinely invalid input.
            let input_parse_result = GLOBALS.set(&Default::default(), || {
                let cm: Lrc<SourceMap> = Default::default();
                parse_js(source, filename, cm)
            });
            match input_parse_result {
                Ok(_) => Ok(None),
                Err(input_parse_error) => Err(anyhow!(
                    "{input_parse_error}; bundle detection also failed: {bundle_parse_error}"
                )),
            }
        }
    }
}

fn detect_bundle_raw(source: &str, filename: &str) -> Result<Option<UnpackResult>> {
    match crate::unpacker::try_unpack_bundle_raw(source) {
        Ok(result) => Ok(result),
        Err(bundle_parse_error) => {
            let input_parse_result = GLOBALS.set(&Default::default(), || {
                let cm: Lrc<SourceMap> = Default::default();
                parse_js(source, filename, cm)
            });
            match input_parse_result {
                Ok(_) => Ok(None),
                Err(input_parse_error) => Err(anyhow!(
                    "{input_parse_error}; bundle detection also failed: {bundle_parse_error}"
                )),
            }
        }
    }
}

fn normalize_raw_unpacked_module(source: &str, filename: &str) -> Result<String> {
    GLOBALS.set(&Default::default(), || {
        let cm: Lrc<SourceMap> = Default::default();
        let mut module = parse_js(source, filename, cm.clone())?;
        let unresolved_mark = Mark::new();
        let top_level_mark = Mark::new();
        module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
        module.visit_mut_with(&mut UnEsm::new(unresolved_mark, RewriteLevel::Standard));
        recover_late_esm_from_factory_iifes(
            &mut module,
            unresolved_mark,
            RewriteLevel::Standard,
            LateEsmRecoveryOptions {
                smart_rename: false,
                export_rename: false,
            },
        );
        apply_fixer(&mut module)?;
        print_js(&module, cm)
    })
}

fn recover_late_esm_from_factory_iifes(
    module: &mut Module,
    unresolved_mark: Mark,
    level: RewriteLevel,
    options: LateEsmRecoveryOptions,
) {
    module.visit_mut_with(&mut ArrowFunction);
    module.visit_mut_with(&mut ArrowReturn);
    module.visit_mut_with(&mut UnIife::new(level));
    apply_rules(
        module,
        unresolved_mark,
        RulePipelineOptions::between("UnCurlyBraces", "UnEsm").with_rewrite_level(level),
    );
    if options.smart_rename {
        module.visit_mut_with(&mut SmartRename::new(unresolved_mark));
    }
    if options.export_rename {
        module.visit_mut_with(&mut UnExportRename);
    }
    module.visit_mut_with(&mut ArrowReturn);
}

#[derive(Clone, Copy)]
struct LateEsmRecoveryOptions {
    smart_rename: bool,
    export_rename: bool,
}

impl Default for LateEsmRecoveryOptions {
    fn default() -> Self {
        Self {
            smart_rename: true,
            export_rename: true,
        }
    }
}

fn unpack_unpack_result(result: UnpackResult, options: DecompileOptions) -> Result<UnpackOutput> {
    let allow_cycle_premerge = result.allow_cycle_premerge;
    let modules = result
        .modules
        .into_iter()
        .map(|module| PreparedUnpackModule::with_cycle_premerge(module, allow_cycle_premerge))
        .collect();
    unpack_multi_module_with_plan(modules, NumericRewritePlan::default(), options)
}

/// Provenance entries for a list of unpacked modules, in module order.
pub(super) fn module_provenance(modules: &[UnpackedModule]) -> Vec<ModuleProvenance> {
    modules
        .iter()
        .map(|module| ModuleProvenance {
            filename: module.filename.clone(),
            input: module.source_input.clone(),
            ranges: module.source_ranges.clone(),
        })
        .collect()
}

/// Provenance entry covering an entire input source.
fn whole_input_provenance(filename: &str, input: &str, source: &str) -> ModuleProvenance {
    ModuleProvenance {
        filename: filename.to_string(),
        input: input.to_string(),
        ranges: vec![(0, source.len() as u32)],
    }
}

fn should_merge_raw_import_cycles(_modules: &[UnpackedModule]) -> bool {
    // Keep the raw merge hook available, but disabled for now. ESM cycles are
    // often valid, and the previous repair could undo recovered module
    // boundaries before users had a chance to inspect raw output.
    false
}

#[cfg(test)]
#[path = "tests.rs"]
mod tests;