crates/core/src/unpacker/browserify.rs
GitHubuse anyhow::anyhow;
use swc_core::atoms::Atom;
use swc_core::common::{sync::Lrc, Mark, SourceMap, Spanned, SyntaxContext, GLOBALS};
use swc_core::ecma::ast::{
ArrayLit, Callee, Expr, ExprOrSpread, ExprStmt, FnExpr, Function, Lit, Module, ModuleItem,
Number, Pat, Stmt,
};
use swc_core::ecma::codegen::{text_writer::JsWriter, Config, Emitter};
use swc_core::ecma::transforms::base::resolver;
use swc_core::ecma::utils::replace_ident;
use swc_core::ecma::visit::VisitMutWith;
use crate::unpacker::{span_byte_range, BundleFormat, UnpackResult, UnpackedModule};
use crate::utils::swc_safety::apply_fixer;
pub fn detect_and_extract(source: &str) -> Option<UnpackResult> {
GLOBALS.set(&Default::default(), || {
let cm: Lrc<SourceMap> = Default::default();
let module = super::parse_es_module(source, "browserify.js", cm.clone()).ok()?;
detect_from_module(&module, cm)
})
}
pub(super) fn detect_from_module(module: &Module, cm: Lrc<SourceMap>) -> Option<UnpackResult> {
for item in &module.body {
let ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) = item else {
continue;
};
let Expr::Call(outer_call) = &**expr else {
continue;
};
let Callee::Expr(callee_expr) = &outer_call.callee else {
continue;
};
let Expr::Call(_) = &**callee_expr else {
continue;
};
if let Some(result) = extract_browserify_modules(outer_call, cm.clone()) {
return Some(result);
}
}
None
}
fn extract_browserify_modules(
call: &swc_core::ecma::ast::CallExpr,
cm: Lrc<SourceMap>,
) -> Option<UnpackResult> {
if call.args.len() != 3 {
return None;
}
let Expr::Array(entry_array) = &*call.args[2].expr else {
return None;
};
let entry_ids = extract_entry_ids(entry_array)?;
let Expr::Object(modules_obj) = &*call.args[0].expr else {
return None;
};
let mut modules = Vec::new();
for prop in &modules_obj.props {
let swc_core::ecma::ast::PropOrSpread::Prop(prop) = prop else {
return None;
};
let swc_core::ecma::ast::Prop::KeyValue(key_value) = &**prop else {
return None;
};
let module_id = match &key_value.key {
swc_core::ecma::ast::PropName::Num(Number { value, .. })
if value.fract() == 0.0 && *value >= 0.0 =>
{
*value as usize
}
_ => return None,
};
let Expr::Array(module_parts) = &*key_value.value else {
return None;
};
let (factory, body_stmts) = extract_factory(module_parts)?;
let code = emit_browserify_module(&factory, body_stmts, cm.clone())?;
let is_entry = entry_ids.contains(&module_id);
let filename = if is_entry && entry_ids.len() == 1 {
"entry.js".to_string()
} else if is_entry {
format!("entry-{module_id}.js")
} else {
format!("module-{module_id}.js")
};
modules.push(UnpackedModule {
id: module_id.to_string(),
is_entry,
code,
filename,
source_ranges: span_byte_range(&cm, key_value.value.span())
.into_iter()
.collect(),
source_input: String::new(),
generated_source_map: Vec::new(),
});
}
if modules.is_empty() {
return None;
}
Some(UnpackResult::new(modules, BundleFormat::Browserify))
}
fn extract_entry_ids(entry_array: &ArrayLit) -> Option<Vec<usize>> {
let mut ids = Vec::new();
for elem in &entry_array.elems {
let Some(ExprOrSpread { expr, .. }) = elem else {
return None;
};
let Expr::Lit(Lit::Num(Number { value, .. })) = &**expr else {
return None;
};
if value.fract() != 0.0 || *value < 0.0 {
return None;
}
ids.push(*value as usize);
}
Some(ids)
}
fn extract_factory(module_parts: &ArrayLit) -> Option<(Function, Vec<Stmt>)> {
if module_parts.elems.len() != 2 {
return None;
}
let Some(ExprOrSpread { expr, .. }) = &module_parts.elems[0] else {
return None;
};
match &**expr {
Expr::Fn(FnExpr { function, .. }) => {
let body = function.body.as_ref()?.stmts.clone();
Some((*function.clone(), body))
}
Expr::Arrow(arrow) => {
let swc_core::ecma::ast::BlockStmtOrExpr::BlockStmt(body) = &*arrow.body else {
return None;
};
let params = arrow
.params
.iter()
.cloned()
.map(|pat| swc_core::ecma::ast::Param {
span: Default::default(),
decorators: vec![],
pat,
})
.collect();
Some((
Function {
params,
decorators: vec![],
span: Default::default(),
ctxt: Default::default(),
body: Some(body.clone()),
is_generator: arrow.is_generator,
is_async: arrow.is_async,
type_params: None,
return_type: None,
},
body.stmts.clone(),
))
}
_ => None,
}
}
fn emit_browserify_module(
factory: &Function,
body_stmts: Vec<Stmt>,
cm: Lrc<SourceMap>,
) -> Option<String> {
let (mut synthetic_module, _) = normalize_extracted_browserify_module(factory, body_stmts);
apply_fixer(&mut synthetic_module).ok()?;
emit_module(&synthetic_module, cm).ok()
}
/// Normalize a browserify factory body into a standalone module.
///
/// Browserify factories use `(require, module, exports)` parameters. This only
/// standardizes those names after resolver marks are assigned; decompiler rules
/// run later in the driver pipeline.
fn normalize_extracted_browserify_module(
factory: &Function,
body_stmts: Vec<Stmt>,
) -> (Module, Mark) {
let mut synthetic_module = build_module_from_stmts(body_stmts);
let param_syms: Vec<Atom> = factory
.params
.iter()
.filter_map(|p| match &p.pat {
Pat::Ident(binding) => Some(binding.sym.clone()),
_ => None,
})
.collect();
let unresolved_mark = Mark::new();
let top_level_mark = Mark::new();
synthetic_module.visit_mut_with(&mut resolver(unresolved_mark, top_level_mark, false));
let unresolved_ctxt = SyntaxContext::empty().apply_mark(unresolved_mark);
for (idx, target) in ["require", "module", "exports"].iter().enumerate() {
let Some(old_sym) = param_syms.get(idx) else {
continue;
};
if old_sym.as_ref() == *target {
continue;
}
let from_id = (old_sym.clone(), unresolved_ctxt);
let to_ident = swc_core::ecma::ast::Ident::new(
Atom::from(*target),
Default::default(),
unresolved_ctxt,
);
replace_ident(&mut synthetic_module, from_id, &to_ident);
}
(synthetic_module, unresolved_mark)
}
fn build_module_from_stmts(stmts: Vec<Stmt>) -> Module {
Module {
span: Default::default(),
body: stmts.into_iter().map(ModuleItem::Stmt).collect(),
shebang: None,
}
}
fn emit_module(module: &Module, cm: Lrc<SourceMap>) -> anyhow::Result<String> {
let mut output = Vec::new();
{
let mut emitter = Emitter {
cfg: Config::default().with_minify(false),
cm: cm.clone(),
comments: None,
wr: JsWriter::new(cm.clone(), "\n", &mut output, None),
};
emitter
.emit_module(module)
.map_err(|e| anyhow!("emit error: {e:?}"))?;
}
String::from_utf8(output).map_err(|e| anyhow!("utf8 error: {e}"))
}