crates/core/src/unpacker/systemjs.rs
GitHubuse std::collections::HashSet;
use swc_core::atoms::Atom;
use swc_core::common::{sync::Lrc, SourceMap, Span, DUMMY_SP};
use swc_core::ecma::ast::{
ArrayLit, BindingIdent, BlockStmt, BlockStmtOrExpr, CallExpr, Callee, Decl, EsVersion,
ExportDecl, ExportDefaultExpr, ExportNamedSpecifier, ExportSpecifier, Expr, ExprOrSpread,
ExprStmt, FnExpr, Function, Ident, ImportDecl, ImportDefaultSpecifier, ImportNamedSpecifier,
ImportSpecifier, ImportStarAsSpecifier, Lit, MemberExpr, MemberProp, MetaPropExpr,
MetaPropKind, Module, ModuleDecl, ModuleExportName, ModuleItem, NamedExport, ObjectLit,
ParenExpr, Pat, Prop, PropName, PropOrSpread, ReturnStmt, Stmt, Str, UnaryOp, VarDecl,
VarDeclarator,
};
use swc_core::ecma::codegen::{text_writer::JsWriter, Config, Emitter};
use swc_core::ecma::visit::{VisitMut, VisitMutWith};
use crate::unpacker::{span_byte_range, BundleFormat, UnpackResult, UnpackedModule};
pub(super) fn detect_from_module(module: &Module, cm: Lrc<SourceMap>) -> Option<UnpackResult> {
let mut registers = Vec::new();
for item in &module.body {
let ModuleItem::Stmt(Stmt::Expr(ExprStmt { expr, .. })) = item else {
continue;
};
match register_from_expr(expr.as_ref()) {
RegisterParse::Register(register) => {
registers.push(register);
continue;
}
RegisterParse::Invalid => return None,
RegisterParse::NotRegister => {}
}
match registers_from_iife_expr(expr.as_ref()) {
IifeRegisterParse::Registers(wrapped_registers) => {
registers.extend(wrapped_registers);
}
IifeRegisterParse::Invalid => return None,
IifeRegisterParse::NotIife => {}
}
}
if registers.is_empty() {
return None;
}
let multiple = registers.len() > 1;
let mut seen = HashSet::new();
let mut modules = Vec::new();
for (idx, register) in registers.into_iter().enumerate() {
let register_range = span_byte_range(&cm, register.span);
if let Some(mut result) = try_unpack_dynamic_export_bundle(®ister, cm.clone()) {
// The nested bundle was re-parsed from emitted code, so its
// spans are meaningless here; attribute the whole register call.
for module in &mut result.modules {
module.source_ranges = register_range.into_iter().collect();
}
modules.extend(result.modules);
continue;
}
let filename = filename_for_register(register.name.as_deref(), idx, multiple, &mut seen);
let code = emit_system_module(®ister, filename.clone(), cm.clone())?;
let is_entry = idx == 0;
modules.push(UnpackedModule {
id: register.name.unwrap_or_else(|| idx.to_string()),
is_entry,
code,
filename,
source_ranges: register_range.into_iter().collect(),
source_input: String::new(),
generated_source_map: Vec::new(),
});
}
Some(UnpackResult::new(modules, BundleFormat::SystemJs))
}
fn try_unpack_dynamic_export_bundle(
register: &SystemRegister,
cm: Lrc<SourceMap>,
) -> Option<UnpackResult> {
let export_sym = param_sym(®ister.declare, 0)?;
let body = register.declare.body.as_ref()?;
let descriptor = extract_register_descriptor(body)?;
let execute_body = descriptor.execute.body.as_ref()?;
let expr = dynamic_export_expr(execute_body, &export_sym)?;
let source = emit_expr_module(expr, cm).ok()?;
crate::unpacker::try_unpack_bundle(&source).ok().flatten()
}
fn dynamic_export_expr<'a>(body: &'a BlockStmt, export_sym: &Atom) -> Option<&'a Expr> {
if body.stmts.len() != 1 {
return None;
}
let Stmt::Expr(expr_stmt) = &body.stmts[0] else {
return None;
};
let Expr::Call(call) = expr_stmt.expr.as_ref() else {
return None;
};
let Callee::Expr(callee) = &call.callee else {
return None;
};
if !matches!(callee.as_ref(), Expr::Ident(id) if id.sym == *export_sym) {
return None;
}
if call.args.len() != 1 || call.args[0].spread.is_some() {
return None;
}
if matches!(call.args[0].expr.as_ref(), Expr::Object(_)) {
return None;
}
Some(call.args[0].expr.as_ref())
}
struct SystemRegister {
name: Option<String>,
deps: Vec<String>,
declare: Function,
/// Span of the whole `System.register(...)` call (provenance).
span: Span,
prelude: Vec<Stmt>,
}
fn is_system_register_call(call: &CallExpr) -> bool {
let Callee::Expr(callee) = &call.callee else {
return false;
};
let Expr::Member(member) = callee.as_ref() else {
return false;
};
if !matches!(member.obj.as_ref(), Expr::Ident(id) if id.sym.as_ref() == "System") {
return false;
}
member_prop_name(&member.prop).is_some_and(|name| name == "register")
}
fn parse_register_call(call: &CallExpr) -> Option<SystemRegister> {
let first = call.args.first()?;
let (name, deps_arg_idx, declare_arg_idx) = match first.expr.as_ref() {
Expr::Lit(Lit::Str(name)) => (Some(name.value.to_string_lossy().to_string()), 1, 2),
_ => (None, 0, 1),
};
let deps = extract_string_array(call.args.get(deps_arg_idx)?.expr.as_ref())?;
let declare = extract_function(call.args.get(declare_arg_idx)?.expr.as_ref())?;
Some(SystemRegister {
name,
deps,
declare,
span: call.span,
prelude: Vec::new(),
})
}
enum RegisterParse {
Register(SystemRegister),
Invalid,
NotRegister,
}
fn register_from_expr(expr: &Expr) -> RegisterParse {
let Expr::Call(call) = expr else {
return RegisterParse::NotRegister;
};
if !is_system_register_call(call) {
return RegisterParse::NotRegister;
}
parse_register_call(call)
.map(RegisterParse::Register)
.unwrap_or(RegisterParse::Invalid)
}
enum IifeRegisterParse {
Registers(Vec<SystemRegister>),
Invalid,
NotIife,
}
fn registers_from_iife_expr(expr: &Expr) -> IifeRegisterParse {
let Some(body) = iife_body(expr) else {
return IifeRegisterParse::NotIife;
};
let mut registers = Vec::new();
for (idx, stmt) in body.stmts.iter().enumerate() {
let Stmt::Expr(expr_stmt) = stmt else {
continue;
};
let mut register = match register_from_expr(expr_stmt.expr.as_ref()) {
RegisterParse::Register(register) => register,
RegisterParse::Invalid => return IifeRegisterParse::Invalid,
RegisterParse::NotRegister => continue,
};
register.prelude = body.stmts[..idx]
.iter()
.filter(|stmt| {
!matches!(stmt, Stmt::Expr(expr) if is_use_strict(expr) || is_register_expr_stmt(expr))
})
.cloned()
.collect();
registers.push(register);
}
IifeRegisterParse::Registers(registers)
}
fn is_register_expr_stmt(expr: &ExprStmt) -> bool {
matches!(
register_from_expr(expr.expr.as_ref()),
RegisterParse::Register(_) | RegisterParse::Invalid
)
}
fn iife_body(expr: &Expr) -> Option<&BlockStmt> {
match expr {
Expr::Paren(paren) => iife_body(paren.expr.as_ref()),
Expr::Unary(unary) if unary.op == UnaryOp::Bang => iife_body(unary.arg.as_ref()),
Expr::Call(call) => match &call.callee {
Callee::Expr(callee) => match callee.as_ref() {
Expr::Fn(function) => function.function.body.as_ref(),
Expr::Arrow(arrow) => match arrow.body.as_ref() {
BlockStmtOrExpr::BlockStmt(body) => Some(body),
BlockStmtOrExpr::Expr(_) => None,
},
Expr::Paren(paren) => iife_body(paren.expr.as_ref()),
_ => None,
},
_ => None,
},
_ => None,
}
}
fn extract_string_array(expr: &Expr) -> Option<Vec<String>> {
let Expr::Array(ArrayLit { elems, .. }) = expr else {
return None;
};
let mut values = Vec::new();
for elem in elems {
let ExprOrSpread { expr, spread: None } = elem.as_ref()? else {
return None;
};
let Expr::Lit(Lit::Str(value)) = expr.as_ref() else {
return None;
};
values.push(value.value.to_string_lossy().to_string());
}
Some(values)
}
fn extract_function(expr: &Expr) -> Option<Function> {
match expr {
Expr::Fn(FnExpr { function, .. }) => Some(*function.clone()),
Expr::Paren(paren) => extract_function(paren.expr.as_ref()),
Expr::Arrow(arrow) => {
let BlockStmtOrExpr::BlockStmt(body) = arrow.body.as_ref() else {
return None;
};
let params = arrow
.params
.iter()
.cloned()
.map(|pat| swc_core::ecma::ast::Param {
span: DUMMY_SP,
decorators: vec![],
pat,
})
.collect();
Some(Function {
params,
decorators: vec![],
span: DUMMY_SP,
ctxt: Default::default(),
body: Some(body.clone()),
is_generator: arrow.is_generator,
is_async: arrow.is_async,
type_params: None,
return_type: None,
})
}
_ => None,
}
}
fn emit_system_module(
register: &SystemRegister,
filename: String,
cm: Lrc<SourceMap>,
) -> Option<String> {
let export_sym = param_sym(®ister.declare, 0)?;
let context_sym = param_sym(®ister.declare, 1);
let body = register.declare.body.as_ref()?;
let descriptor = extract_register_descriptor(body)?;
let execute_body = descriptor.execute.body.as_ref()?;
let imports = collect_imports(®ister.deps, &descriptor.setters)?;
let imported_locals = imports
.iter()
.flat_map(|import| import.local_names())
.collect::<HashSet<_>>();
let mut items = Vec::new();
for import in &imports {
items.extend(import.to_module_items());
}
items.extend(register.prelude.iter().cloned().map(ModuleItem::Stmt));
let mut transformer = SystemExecuteTransformer::new(export_sym, context_sym);
for stmt in outer_hoisted_stmts(body, &imported_locals) {
transformer.push_stmt(stmt, &mut items);
}
for stmt in &execute_body.stmts {
transformer.push_stmt(stmt.clone(), &mut items);
}
items.extend(transformer.export_items());
let module = Module {
span: DUMMY_SP,
body: items,
shebang: None,
};
emit_module(&module, filename, cm).ok()
}
struct RegisterDescriptor {
setters: Vec<Option<Function>>,
execute: Function,
}
fn extract_register_descriptor(body: &BlockStmt) -> Option<RegisterDescriptor> {
let return_stmt = body.stmts.iter().find_map(|stmt| match stmt {
Stmt::Return(ReturnStmt { arg: Some(arg), .. }) => Some(arg.as_ref()),
_ => None,
})?;
let Expr::Object(obj) = return_stmt else {
return None;
};
let mut setters = None;
let mut execute = None;
for prop in &obj.props {
let PropOrSpread::Prop(prop) = prop else {
continue;
};
match prop.as_ref() {
Prop::KeyValue(key_value) => match prop_name(&key_value.key).as_deref() {
Some("setters") => setters = Some(extract_setters(key_value.value.as_ref())?),
Some("execute") => execute = Some(extract_function(key_value.value.as_ref())?),
_ => {}
},
Prop::Method(method) if prop_name(&method.key).as_deref() == Some("execute") => {
execute = Some(*method.function.clone());
}
_ => {}
}
}
Some(RegisterDescriptor {
setters: setters.unwrap_or_default(),
execute: execute?,
})
}
fn extract_setters(expr: &Expr) -> Option<Vec<Option<Function>>> {
let Expr::Array(array) = expr else {
return None;
};
let mut setters = Vec::new();
for elem in &array.elems {
let Some(ExprOrSpread { expr, spread: None }) = elem else {
setters.push(None);
continue;
};
if matches!(expr.as_ref(), Expr::Ident(id) if id.sym.as_ref() == "undefined")
|| matches!(expr.as_ref(), Expr::Lit(Lit::Null(_)))
{
setters.push(None);
continue;
}
setters.push(Some(extract_function(expr.as_ref())?));
}
Some(setters)
}
fn outer_hoisted_stmts(body: &BlockStmt, imported_locals: &HashSet<Atom>) -> Vec<Stmt> {
let mut out = Vec::new();
for stmt in &body.stmts {
match stmt {
Stmt::Return(_) => {}
Stmt::Expr(expr) if is_use_strict(expr) => {}
Stmt::Decl(Decl::Var(var)) => {
let mut var = *var.clone();
var.decls.retain(|decl| {
!pat_single_ident(&decl.name).is_some_and(|name| {
imported_locals.contains(name) || name.as_ref() == "__moduleName"
})
});
if !var.decls.is_empty() {
out.push(Stmt::Decl(Decl::Var(Box::new(var))));
}
}
_ => out.push(stmt.clone()),
}
}
out
}
#[derive(Default)]
struct ImportParts {
source: String,
default: Option<Atom>,
namespace: Option<Atom>,
named: Vec<(Atom, Atom)>,
}
impl ImportParts {
fn local_names(&self) -> Vec<Atom> {
let mut names = Vec::new();
names.extend(self.default.clone());
names.extend(self.namespace.clone());
names.extend(self.named.iter().map(|(_, local)| local.clone()));
names
}
fn to_module_items(&self) -> Vec<ModuleItem> {
let mut items = Vec::new();
let src = make_str(&self.source);
if self.default.is_none() && self.namespace.is_none() && self.named.is_empty() {
items.push(ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
span: DUMMY_SP,
specifiers: vec![],
src: Box::new(src),
type_only: false,
with: None,
phase: Default::default(),
})));
return items;
}
if let Some(namespace) = &self.namespace {
items.push(ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
span: DUMMY_SP,
specifiers: vec![ImportSpecifier::Namespace(ImportStarAsSpecifier {
span: DUMMY_SP,
local: ident(namespace.clone()),
})],
src: Box::new(src.clone()),
type_only: false,
with: None,
phase: Default::default(),
})));
}
let mut specifiers = Vec::new();
if let Some(default) = &self.default {
specifiers.push(ImportSpecifier::Default(ImportDefaultSpecifier {
span: DUMMY_SP,
local: ident(default.clone()),
}));
}
specifiers.extend(self.named.iter().map(|(imported, local)| {
ImportSpecifier::Named(ImportNamedSpecifier {
span: DUMMY_SP,
local: ident(local.clone()),
imported: (imported != local).then(|| {
ModuleExportName::Ident(Ident::new(
imported.clone(),
DUMMY_SP,
Default::default(),
))
}),
is_type_only: false,
})
}));
if !specifiers.is_empty() {
items.push(ModuleItem::ModuleDecl(ModuleDecl::Import(ImportDecl {
span: DUMMY_SP,
specifiers,
src: Box::new(src),
type_only: false,
with: None,
phase: Default::default(),
})));
}
items
}
}
fn collect_imports(deps: &[String], setters: &[Option<Function>]) -> Option<Vec<ImportParts>> {
let mut imports = Vec::new();
for (idx, dep) in deps.iter().enumerate() {
let mut parts = ImportParts {
source: dep.clone(),
..Default::default()
};
let Some(Some(setter)) = setters.get(idx) else {
imports.push(parts);
continue;
};
let module_sym = param_sym(setter, 0);
let body = setter.body.as_ref()?;
if body.stmts.is_empty() {
imports.push(parts);
continue;
}
let module_sym = module_sym?;
for stmt in &body.stmts {
for (local, kind) in setter_assignments(stmt, &module_sym)? {
match kind {
SetterImportKind::Default => parts.default = Some(local),
SetterImportKind::Named(imported) => parts.named.push((imported, local)),
SetterImportKind::Namespace => parts.namespace = Some(local),
}
}
}
imports.push(parts);
}
Some(imports)
}
enum SetterImportKind {
Default,
Named(Atom),
Namespace,
}
fn setter_assignments(stmt: &Stmt, module_sym: &Atom) -> Option<Vec<(Atom, SetterImportKind)>> {
let Stmt::Expr(expr_stmt) = stmt else {
return None;
};
match expr_stmt.expr.as_ref() {
Expr::Seq(seq) => seq
.exprs
.iter()
.map(|expr| setter_assignment_expr(expr.as_ref(), module_sym))
.collect(),
expr => setter_assignment_expr(expr, module_sym).map(|assignment| vec![assignment]),
}
}
fn setter_assignment_expr(expr: &Expr, module_sym: &Atom) -> Option<(Atom, SetterImportKind)> {
let Expr::Assign(assign) = expr else {
return None;
};
let left = assign.left.as_simple()?.as_ident()?.sym.clone();
match assign.right.as_ref() {
Expr::Ident(id) if id.sym == *module_sym => Some((left, SetterImportKind::Namespace)),
Expr::Member(member) if member_obj_ident(member, module_sym) => {
let imported = member_prop_name(&member.prop)?;
if imported.as_ref() == "default" {
Some((left, SetterImportKind::Default))
} else {
Some((left, SetterImportKind::Named(imported)))
}
}
_ => None,
}
}
struct SystemExecuteTransformer {
export_sym: Atom,
context_sym: Option<Atom>,
exports: Vec<ExportBinding>,
}
impl SystemExecuteTransformer {
fn new(export_sym: Atom, context_sym: Option<Atom>) -> Self {
Self {
export_sym,
context_sym,
exports: Vec::new(),
}
}
fn push_stmt(&mut self, mut stmt: Stmt, items: &mut Vec<ModuleItem>) {
if let Some(export_items) = self.take_export_stmt(&stmt) {
items.extend(export_items);
return;
}
if let Stmt::Decl(Decl::Var(var)) = &mut stmt {
self.rewrite_var_exports(var);
}
stmt.visit_mut_with(self);
items.push(ModuleItem::Stmt(stmt));
}
fn export_items(self) -> Vec<ModuleItem> {
if self.exports.is_empty() {
return Vec::new();
}
let specifiers = self
.exports
.into_iter()
.map(|binding| {
let local = binding.local;
let exported = binding.exported;
ExportSpecifier::Named(ExportNamedSpecifier {
span: DUMMY_SP,
orig: ModuleExportName::Ident(ident(local.clone())),
exported: if exported.as_ref() == local.as_ref() {
None
} else {
Some(ModuleExportName::Ident(ident(exported)))
},
is_type_only: false,
})
})
.collect();
vec![ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(
NamedExport {
span: DUMMY_SP,
specifiers,
src: None,
type_only: false,
with: None,
},
))]
}
fn take_export_stmt(&mut self, stmt: &Stmt) -> Option<Vec<ModuleItem>> {
let Stmt::Expr(expr_stmt) = stmt else {
return None;
};
match expr_stmt.expr.as_ref() {
Expr::Call(call) => {
let export_call = parse_export_call(call, &self.export_sym)?;
self.export_call_items(export_call)
}
Expr::Seq(seq) => {
let mut items = Vec::new();
let mut saw_export = false;
for expr in &seq.exprs {
let export_call = match expr.as_ref() {
Expr::Call(call) => parse_export_call(call, &self.export_sym),
_ => None,
};
if let Some(export_call) = export_call {
items.extend(self.export_call_items(export_call)?);
saw_export = true;
} else {
let mut stmt = Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: expr.clone(),
});
stmt.visit_mut_with(self);
items.push(ModuleItem::Stmt(stmt));
}
}
saw_export.then_some(items)
}
_ => None,
}
}
fn export_call_items(&mut self, export_call: ExportCall) -> Option<Vec<ModuleItem>> {
match export_call {
ExportCall::Single { exported, value } => {
if let Expr::Assign(assign) = value.as_ref() {
let local = assign.left.as_simple()?.as_ident()?.sym.clone();
self.add_export(local, exported);
return Some(vec![ModuleItem::Stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: value,
}))]);
}
if let Some(local) = exported_value_local(value.as_ref()) {
self.add_export(local, exported);
return Some(Vec::new());
}
if exported.as_ref() == "default" {
return Some(vec![ModuleItem::ModuleDecl(ModuleDecl::ExportDefaultExpr(
ExportDefaultExpr {
span: DUMMY_SP,
expr: value,
},
))]);
}
if is_valid_ident_name(exported.as_ref()) {
return Some(vec![ModuleItem::ModuleDecl(ModuleDecl::ExportDecl(
ExportDecl {
span: DUMMY_SP,
decl: Decl::Var(Box::new(VarDecl {
span: DUMMY_SP,
ctxt: Default::default(),
kind: swc_core::ecma::ast::VarDeclKind::Const,
declare: false,
decls: vec![VarDeclarator {
span: DUMMY_SP,
name: Pat::Ident(BindingIdent {
id: ident(exported),
type_ann: None,
}),
init: Some(value),
definite: false,
}],
})),
},
))]);
}
None
}
ExportCall::Bulk(exports) => {
let mut assignment_items = Vec::new();
for (exported, value) in exports {
let local = exported_value_local(value.as_ref())?;
self.add_export(local, exported);
if matches!(value.as_ref(), Expr::Assign(_)) {
assignment_items.push(ModuleItem::Stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: value,
})));
}
}
Some(assignment_items)
}
}
}
fn rewrite_var_exports(&mut self, var: &mut Box<VarDecl>) {
for decl in &mut var.decls {
let Some(init) = &mut decl.init else {
continue;
};
let Expr::Call(call) = init.as_ref() else {
continue;
};
let Some(ExportCall::Single { exported, value }) =
parse_export_call(call, &self.export_sym)
else {
continue;
};
let Some(local) = pat_single_ident(&decl.name).cloned() else {
continue;
};
self.add_export(local, exported);
*init = value;
}
}
fn add_export(&mut self, local: Atom, exported: Atom) {
if self
.exports
.iter()
.any(|existing| existing.local == local && existing.exported == exported)
{
return;
}
self.exports.push(ExportBinding { local, exported });
}
}
impl VisitMut for SystemExecuteTransformer {
fn visit_mut_call_expr(&mut self, call: &mut CallExpr) {
if self.is_context_import(call) {
call.callee = Callee::Import(swc_core::ecma::ast::Import {
span: DUMMY_SP,
phase: Default::default(),
});
}
call.visit_mut_children_with(self);
}
fn visit_mut_expr(&mut self, expr: &mut Expr) {
if let Expr::Member(member) = expr {
if self.is_context_meta(member) {
*expr = Expr::MetaProp(MetaPropExpr {
span: DUMMY_SP,
kind: MetaPropKind::ImportMeta,
});
return;
}
}
if let Expr::Call(call) = expr {
if let Some(ExportCall::Single { exported, value }) =
parse_export_call(call, &self.export_sym)
{
if let Some(local) = exported_value_local(value.as_ref()) {
self.add_export(local, exported);
}
*expr = export_replacement_expr(value);
expr.visit_mut_children_with(self);
return;
}
}
expr.visit_mut_children_with(self);
}
}
impl SystemExecuteTransformer {
fn is_context_import(&self, call: &CallExpr) -> bool {
let Some(context_sym) = &self.context_sym else {
return false;
};
let Callee::Expr(callee) = &call.callee else {
return false;
};
let Expr::Member(member) = callee.as_ref() else {
return false;
};
member_obj_ident(member, context_sym)
&& member_prop_name(&member.prop).is_some_and(|prop| prop.as_ref() == "import")
}
fn is_context_meta(&self, member: &MemberExpr) -> bool {
let Some(context_sym) = &self.context_sym else {
return false;
};
member_obj_ident(member, context_sym)
&& member_prop_name(&member.prop).is_some_and(|prop| prop.as_ref() == "meta")
}
}
#[derive(Clone)]
struct ExportBinding {
local: Atom,
exported: Atom,
}
enum ExportCall {
Single { exported: Atom, value: Box<Expr> },
Bulk(Vec<(Atom, Box<Expr>)>),
}
fn parse_export_call(call: &CallExpr, export_sym: &Atom) -> Option<ExportCall> {
let Callee::Expr(callee) = &call.callee else {
return None;
};
if !matches!(callee.as_ref(), Expr::Ident(id) if id.sym == *export_sym) {
return None;
}
if call.args.len() == 2 {
let exported = string_lit_arg(&call.args[0])?;
let value = call.args[1].expr.clone();
return Some(ExportCall::Single { exported, value });
}
if call.args.len() == 1 {
let Expr::Object(object) = call.args[0].expr.as_ref() else {
return None;
};
return Some(ExportCall::Bulk(object_export_pairs(object)?));
}
None
}
fn object_export_pairs(object: &ObjectLit) -> Option<Vec<(Atom, Box<Expr>)>> {
let mut pairs = Vec::new();
for prop in &object.props {
let PropOrSpread::Prop(prop) = prop else {
return None;
};
match prop.as_ref() {
Prop::Shorthand(id) => pairs.push((id.sym.clone(), Box::new(Expr::Ident(id.clone())))),
Prop::KeyValue(kv) => pairs.push((prop_name(&kv.key)?.into(), kv.value.clone())),
_ => return None,
}
}
Some(pairs)
}
fn exported_value_local(expr: &Expr) -> Option<Atom> {
match expr {
Expr::Ident(id) => Some(id.sym.clone()),
Expr::Assign(assign) => assign.left.as_simple()?.as_ident().map(|id| id.sym.clone()),
_ => None,
}
}
fn export_replacement_expr(value: Box<Expr>) -> Expr {
if matches!(value.as_ref(), Expr::Assign(_)) {
Expr::Paren(ParenExpr {
span: DUMMY_SP,
expr: value,
})
} else {
*value
}
}
fn string_lit_arg(arg: &ExprOrSpread) -> Option<Atom> {
if arg.spread.is_some() {
return None;
}
let Expr::Lit(Lit::Str(s)) = arg.expr.as_ref() else {
return None;
};
Some(Atom::from(s.value.as_str()?))
}
fn param_sym(function: &Function, idx: usize) -> Option<Atom> {
let param = function.params.get(idx)?;
pat_single_ident(¶m.pat).cloned()
}
fn pat_single_ident(pat: &Pat) -> Option<&Atom> {
match pat {
Pat::Ident(binding) => Some(&binding.id.sym),
_ => None,
}
}
fn is_use_strict(expr: &ExprStmt) -> bool {
matches!(expr.expr.as_ref(), Expr::Lit(Lit::Str(s)) if s.value.as_str() == Some("use strict"))
}
fn member_obj_ident(member: &MemberExpr, sym: &Atom) -> bool {
matches!(member.obj.as_ref(), Expr::Ident(id) if id.sym == *sym)
}
fn member_prop_name(prop: &MemberProp) -> Option<Atom> {
match prop {
MemberProp::Ident(id) => Some(id.sym.clone()),
MemberProp::Computed(computed) => match computed.expr.as_ref() {
Expr::Lit(Lit::Str(s)) => Some(Atom::from(s.value.as_str()?)),
_ => None,
},
MemberProp::PrivateName(_) => None,
}
}
fn prop_name(prop: &PropName) -> Option<String> {
match prop {
PropName::Ident(id) => Some(id.sym.to_string()),
PropName::Str(s) => Some(s.value.to_string_lossy().to_string()),
PropName::Num(n) if n.value.fract() == 0.0 => Some((n.value as i64).to_string()),
_ => None,
}
}
fn ident(sym: Atom) -> Ident {
Ident::new(sym, DUMMY_SP, Default::default())
}
fn make_str(value: &str) -> Str {
Str {
span: DUMMY_SP,
value: value.into(),
raw: None,
}
}
fn filename_for_register(
name: Option<&str>,
idx: usize,
multiple: bool,
seen: &mut HashSet<String>,
) -> String {
let base = match name {
Some(name) => sanitize_filename(name),
None if multiple => format!("module-{idx}.js"),
None => "entry.js".to_string(),
};
dedup_filename(&base, seen)
}
fn sanitize_filename(module_id: &str) -> String {
let mut filename = crate::unpacker::sanitize_relative_path(module_id, "unknown");
if !filename
.rsplit('/')
.next()
.is_some_and(|leaf| leaf.contains('.'))
{
filename.push_str(".js");
}
filename
}
fn dedup_filename(filename: &str, seen: &mut HashSet<String>) -> String {
if seen.insert(filename.to_ascii_lowercase()) {
return filename.to_string();
}
let (stem, ext) = match filename.rfind('.') {
Some(i) => (&filename[..i], &filename[i + 1..]),
None => (filename, "js"),
};
let mut n = 2u32;
loop {
let candidate = format!("{stem}_{n}.{ext}");
if seen.insert(candidate.to_ascii_lowercase()) {
return candidate;
}
n += 1;
}
}
fn is_valid_ident_name(name: &str) -> bool {
let mut chars = name.chars();
let Some(first) = chars.next() else {
return false;
};
(first == '_' || first == '$' || first.is_ascii_alphabetic())
&& chars.all(|c| c == '_' || c == '$' || c.is_ascii_alphanumeric())
}
fn emit_module(module: &Module, filename: String, cm: Lrc<SourceMap>) -> anyhow::Result<String> {
let _fm = cm.new_source_file(
swc_core::common::FileName::Custom(filename).into(),
String::new(),
);
let mut output = Vec::new();
{
let mut emitter = Emitter {
cfg: Config::default()
.with_minify(false)
.with_target(EsVersion::EsNext),
cm: cm.clone(),
comments: None,
wr: JsWriter::new(cm.clone(), "\n", &mut output, None),
};
emitter.emit_module(module)?;
}
String::from_utf8(output).map_err(|e| anyhow::anyhow!("{e}"))
}
fn emit_expr_module(expr: &Expr, cm: Lrc<SourceMap>) -> anyhow::Result<String> {
let module = Module {
span: DUMMY_SP,
body: vec![ModuleItem::Stmt(Stmt::Expr(ExprStmt {
span: DUMMY_SP,
expr: Box::new(expr.clone()),
}))],
shebang: None,
};
emit_module(&module, "systemjs-inner-bundle.js".to_string(), cm)
}
#[cfg(test)]
mod tests {
use super::*;
fn unpack(source: &str) -> UnpackResult {
let cm: Lrc<SourceMap> = Default::default();
let module = crate::unpacker::parse_es_module(source, "system.js", cm.clone()).unwrap();
detect_from_module(&module, cm).expect("should detect System.register")
}
#[test]
fn anonymous_register_uses_entry_filename() {
let result = unpack(
r#"
System.register([], function (exports) {
return {
execute: function () {
const value = exports("value", 1);
}
};
});
"#,
);
assert_eq!(result.modules.len(), 1);
assert_eq!(result.modules[0].filename, "entry.js");
assert!(result.modules[0].code.contains("const value = 1"));
assert!(result.modules[0].code.contains("export { value };"));
}
#[test]
fn named_register_sanitizes_filename() {
let result = unpack(
r#"
System.register("../chunks/main", [], function (exports) {
return { execute: function () { exports("default", 1); } };
});
"#,
);
assert_eq!(result.modules[0].filename, "chunks/main.js");
}
#[test]
fn object_method_execute_reconstructs_module() {
let result = unpack(
r#"
System.register(["./dep.js"], (_export) => {
let value;
let label;
return {
setters: [
(module) => {
value = module.value, label = module.label;
}
],
execute () {
_export("default", `${label}:${value + 1}`);
}
};
});
"#,
);
assert_eq!(result.modules.len(), 1);
assert_eq!(result.modules[0].filename, "entry.js");
assert!(result.modules[0]
.code
.contains(r#"import { value, label } from "./dep.js";"#));
assert!(result.modules[0]
.code
.contains("export default `${label}:${value + 1}`;"));
}
#[test]
fn iife_wrapped_register_preserves_helper_prelude() {
let result = unpack(
r#"
!function () {
"use strict";
function decorate(value) {
return value + "!";
}
System.register([], function (_export) {
return {
execute: function () {
_export("default", decorate("ready"));
}
};
});
}();
"#,
);
assert_eq!(result.modules.len(), 1);
assert_eq!(result.modules[0].filename, "entry.js");
assert!(result.modules[0].code.contains("function decorate(value)"));
assert!(result.modules[0]
.code
.contains("export default decorate(\"ready\");"));
assert!(!result.modules[0].code.contains("use strict"));
}
#[test]
fn iife_wrapped_multiple_registers_do_not_copy_prior_registers_into_prelude() {
let result = unpack(
r#"
!function () {
function decorate(value) {
return value + "!";
}
System.register("first", [], function (_export) {
return {
execute: function () {
_export("default", decorate("one"));
}
};
});
System.register("second", [], function (_export) {
return {
execute: function () {
_export("default", decorate("two"));
}
};
});
}();
"#,
);
assert_eq!(result.modules.len(), 2);
assert_eq!(result.modules[1].filename, "second.js");
assert!(result.modules[1].code.contains("function decorate(value)"));
assert!(result.modules[1]
.code
.contains("export default decorate(\"two\");"));
assert!(
!result.modules[1].code.contains("System.register"),
"later modules must not copy prior register calls as prelude:\n{}",
result.modules[1].code
);
assert!(
!result.modules[1].code.contains("decorate(\"one\")"),
"later modules must not copy prior register execute bodies:\n{}",
result.modules[1].code
);
}
#[test]
fn null_setters_reconstruct_imports() {
let result = unpack(
r#"
!function () {
function decorate(value) {
return value;
}
System.register(["./side-effect.js", "./dep.js"], function (_export) {
var component;
return {
setters: [
null,
function (module) {
component = module.component;
}
],
execute: function () {
const button = _export("V", decorate(component));
}
};
});
}();
"#,
);
assert_eq!(result.modules.len(), 1);
assert!(result.modules[0]
.code
.contains(r#"import "./side-effect.js";"#));
assert!(result.modules[0]
.code
.contains(r#"import { component } from "./dep.js";"#));
assert!(result.modules[0]
.code
.contains("const button = decorate(component);"));
assert!(result.modules[0].code.contains("export { button as V };"));
}
#[test]
fn sequence_export_calls_reconstruct_each_export() {
let result = unpack(
r#"
System.register([], function (_export) {
function make(value) {
return { value };
}
return {
execute: function () {
_export("C", make(1)), _export("_", make(2));
}
};
});
"#,
);
assert_eq!(result.modules.len(), 1);
assert!(result.modules[0].code.contains("export const C = make(1);"));
assert!(result.modules[0].code.contains("export const _ = make(2);"));
}
#[test]
fn mixed_sequence_side_effects_preserve_direct_export_value() {
let result = unpack(
r#"
System.register([], function (_export) {
return {
execute: function () {
style.textContent = ".badge{}", document.head.appendChild(style), _export("_", defineComponent({
__name: "TeamBadge"
}));
}
};
});
"#,
);
assert_eq!(result.modules.len(), 1);
assert!(result.modules[0]
.code
.contains("style.textContent = \".badge{}\";"));
assert!(result.modules[0]
.code
.contains("document.head.appendChild(style);"));
assert!(result.modules[0]
.code
.contains("export const _ = defineComponent({"));
}
#[test]
fn assignment_export_in_logical_member_object_is_parenthesized() {
let result = unpack(
r#"
System.register([], function (_export) {
var Kind;
return {
execute: function () {
(Kind || _export("Kind", Kind = {})).Ready = "Ready";
}
};
});
"#,
);
assert_eq!(result.modules.len(), 1);
assert!(result.modules[0]
.code
.contains("(Kind || (Kind = {})).Ready = \"Ready\";"));
assert!(result.modules[0].code.contains("export { Kind };"));
}
#[test]
fn ignores_unrelated_top_level_expressions() {
let result = unpack(
r#"
console.log("loading");
System.register([], function (_export) {
return {
execute: function () {
_export("default", 1);
}
};
});
"#,
);
assert_eq!(result.modules.len(), 1);
assert!(result.modules[0].code.contains("export default 1;"));
}
#[test]
fn named_register_does_not_create_traversal_from_overlapping_dots() {
let result = unpack(
r#"
System.register("....//chunks/main", [], function (exports) {
return { execute: function () { exports("default", 1); } };
});
"#,
);
assert_eq!(result.modules[0].filename, "..../chunks/main.js");
}
}