@swc-contrib/mut-cjs-exports 10.7.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) magic-akari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,120 @@
+# [SWC plugin] mutable CJS exports
+
+Migrated from https://github.com/magic-akari/swc_mut_cjs_exports
+
+This is a SWC plugin to emit mutable CJS exports.
+
+This SWC plugin has only been tested for compatibility with jest. It should be used with `@swc/jest`.
+
+This project was previously called jest_workaround
+
+## plugin version
+
+https://swc.rs/docs/plugin/selecting-swc-core
+
+## usage
+
+install
+
+```bash
+npm i -D jest @swc/core @swc/jest @swc-contrib/mut-cjs-exports
+```
+
+```js
+// jest.config.js
+const fs = require("node:fs");
+
+const swcrc = JSON.parse(fs.readFileSync(".swcrc", "utf8"));
+
+// If you have other plugins, change this line.
+((swcrc.jsc ??= {}).experimental ??= {}).plugins = [
+  ["@swc-contrib/mut-cjs-exports", {}],
+];
+
+module.exports = {
+  transform: {
+    "^.+\\.(t|j)sx?$": ["@swc/jest", swcrc],
+  },
+};
+```
+
+Alternative implementation without .swcrc file
+
+```JavaScript
+// jest.config.js
+
+module.exports = {
+  transform: {
+    "^.+\\.(t|j)sx?$": [
+      "@swc/jest",
+      {
+        jsc: {
+          experimental: {
+            plugins: [["@swc-contrib/mut-cjs-exports", {}]],
+          },
+        },
+      },
+    ],
+  },
+};
+```
+
+Make sure that `module.type` is `commonjs` in your `.swcrc` since this plugin
+does not touch non-workaround parts, such as import statements.
+
+## FAQ
+
+#### 1. When do I need this?
+
+If you're using the swc compiler to transform your code to comply with the ESM
+specification, but you're also using Jest to test it in a CJS environment, you
+may encounter issues due to the immutable issue of `exports`.
+
+This plugin can help by transforming the `export` statements into mutable
+`exports`.
+
+#### 2. Do I have a better choice?
+
+You may have other options depending on your specific needs:
+
+- If you're able to run Jest in an ESM environment, you can use swc to transpile
+  TypeScript/JSX syntax or downgrade JavaScript syntax without module
+  conversion. Simply set the value of `module.type` to `es6` to achieve this.
+
+- It's possible that some issues related to running Jest in an ESM environment
+  will be resolved over time. Keep an eye on
+  [facebook/jest#9430](https://github.com/facebook/jest/issues/9430) for
+  updates.
+
+- If you don't need the behavior of ESM specifically, you can stick with the CJS
+  syntax to get the CJS behavior of `exports`.
+
+These options may be worth considering before using this plugin.
+
+CJS syntax
+
+```JavaScript
+exports.foo = function foo() {
+  return 42;
+};
+```
+
+CTS(CJS in TypeScript) syntax
+
+```TypeScript
+export = {
+  foo: function foo() {
+    return 42;
+  },
+};
+```
+
+Notes:
+
+- ESM style export means immutable exports when transformed into CJS
+- ESM style import means hoisted require when transformed into CJS
+
+#### 3. After upgrading the plugin version, the changes have not taken effect.
+
+This is a known issue. You could remove the Jest cache by running
+[`jest --clearCache`](https://jestjs.io/docs/cli#--clearcache) as a workaround.

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@swc-contrib/mut-cjs-exports",
+  "version": "10.7.0",
+  "description": "[SWC plugin] mutable CJS exports",
+  "author": "magic-akari <akari.ccino@gmail.com>",
+  "license": "MIT",
+  "keywords": [
+    "swc-plugin",
+    "swc",
+    "jest",
+    "cjs",
+    "commonjs"
+  ],
+  "main": "swc_mut_cjs_exports.wasm",
+  "files": [
+    "src",
+    "swc_mut_cjs_exports.wasm"
+  ],
+  "homepage": "https://github.com/magic-akari/swc_mut_cjs_exports#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magic-akari/swc_mut_cjs_exports.git"
+  },
+  "bugs": {
+    "url": "https://github.com/magic-akari/swc_mut_cjs_exports/issues"
+  },
+  "devDependencies": {
+    "@swc/core": "^1.10.0",
+    "@swc/jest": "^0.2.37",
+    "@types/jest": "^29.5.11",
+    "jest": "^29.7.0"
+  },
+  "peerDependencies": {
+    "@swc/core": "^1.10.0",
+    "@swc/jest": "^0.2.37"
+  },
+  "scripts": {
+    "build": "cargo build --release --target wasm32-unknown-unknown && cp ../../target/wasm32-unknown-unknown/release/swc_mut_cjs_exports.wasm .",
+    "build:debug": "cargo build --target wasm32-unknown-unknown && cp ../../target/wasm32-unknown-unknown/debug/swc_mut_cjs_exports.wasm ./swc_mut_cjs_exports_debug.wasm",
+    "test": "pnpm run build:debug && jest"
+  }
+}

package/src/lib.rs

@@ -0,0 +1,325 @@
+mod local_export_strip;
+mod utils;
+
+use local_export_strip::LocalExportStrip;
+use rustc_hash::FxHashSet;
+use swc_core::{
+    common::{util::take::Take, Mark, SyntaxContext, DUMMY_SP},
+    ecma::{
+        ast::*,
+        utils::{
+            for_each_binding_ident, member_expr, private_ident, quote_ident, quote_str,
+            ExprFactory, IntoIndirectCall,
+        },
+        visit::{noop_visit_mut_type, VisitMut, VisitMutWith},
+    },
+    plugin::{plugin_transform, proxies::TransformPluginProgramMetadata},
+};
+use utils::{emit_export_stmts, object_define_property};
+
+#[derive(Debug)]
+pub struct TransformVisitor {
+    unresolved_mark: Mark,
+
+    export_decl_id: FxHashSet<Id>,
+}
+
+impl VisitMut for TransformVisitor {
+    noop_visit_mut_type!();
+
+    fn visit_mut_script(&mut self, _: &mut Script) {
+        // skip
+    }
+
+    fn visit_mut_module(&mut self, n: &mut Module) {
+        let mut strip = LocalExportStrip::default();
+        n.visit_mut_with(&mut strip);
+
+        let LocalExportStrip {
+            has_export_assign,
+            export,
+            export_all,
+            export_decl_id,
+            ..
+        } = strip;
+
+        self.export_decl_id = export_decl_id;
+
+        let mut stmts: Vec<ModuleItem> = Vec::with_capacity(n.body.len() + 1);
+
+        if !has_export_assign && !export.is_empty() {
+            // keep module env
+            stmts.push(ModuleItem::ModuleDecl(ModuleDecl::ExportNamed(
+                NamedExport::dummy(),
+            )));
+
+            let exports = self.exports();
+
+            stmts.extend(
+                emit_export_stmts(exports, export)
+                    .into_iter()
+                    .map(Into::into),
+            );
+
+            if !self.export_decl_id.is_empty() {
+                n.visit_mut_children_with(self);
+            }
+        }
+
+        stmts.extend(export_all.into_iter().map(|id| self.export_all(id)));
+
+        stmts.extend(n.body.take());
+
+        n.body = stmts;
+    }
+
+    fn visit_mut_function(&mut self, node: &mut Function) {
+        let export_decl_id = self.export_decl_id.clone();
+
+        for_each_binding_ident(&node.params, |ident| {
+            self.export_decl_id.remove(&ident.id.to_id());
+        });
+
+        node.visit_mut_children_with(self);
+        self.export_decl_id = export_decl_id;
+    }
+
+    fn visit_mut_prop(&mut self, n: &mut Prop) {
+        match n {
+            Prop::Shorthand(ref_ident) => {
+                if self.export_decl_id.contains(&ref_ident.to_id()) {
+                    *n = KeyValueProp {
+                        key: ref_ident.clone().into(),
+                        value: Box::new(self.exports().make_member(ref_ident.take().into()).into()),
+                    }
+                    .into()
+                }
+            }
+            _ => n.visit_mut_children_with(self),
+        }
+    }
+
+    fn visit_mut_expr(&mut self, n: &mut Expr) {
+        match n {
+            Expr::Ident(ref_ident) => {
+                if self.export_decl_id.contains(&ref_ident.to_id()) {
+                    *n = self.exports().make_member(ref_ident.take().into()).into();
+                }
+            }
+
+            _ => n.visit_mut_children_with(self),
+        };
+    }
+
+    fn visit_mut_tagged_tpl(&mut self, n: &mut TaggedTpl) {
+        let is_indirect = n
+            .tag
+            .as_ident()
+            .map(|ident| self.export_decl_id.contains(&ident.to_id()))
+            .unwrap_or_default();
+
+        n.visit_mut_children_with(self);
+
+        if is_indirect {
+            *n = n.take().into_indirect()
+        }
+    }
+
+    fn visit_mut_callee(&mut self, n: &mut Callee) {
+        match n {
+            Callee::Expr(e) if e.is_ident() => {
+                let is_indirect_callee = e
+                    .as_ident()
+                    .map(|ident| self.export_decl_id.contains(&ident.to_id()))
+                    .unwrap_or_default();
+
+                e.visit_mut_with(self);
+
+                if is_indirect_callee {
+                    *n = n.take().into_indirect()
+                }
+            }
+
+            _ => n.visit_mut_children_with(self),
+        }
+    }
+
+    fn visit_mut_jsx_element_name(&mut self, n: &mut JSXElementName) {
+        match n {
+            JSXElementName::Ident(ref_ident) => {
+                if self.export_decl_id.contains(&ref_ident.to_id()) {
+                    *n = JSXElementName::JSXMemberExpr(
+                        JSXMemberExpr {
+                            span: DUMMY_SP,
+                            obj: self.exports().into(),
+                            prop: ref_ident.clone().into(),
+                        }
+                        .into(),
+                    );
+                }
+            }
+            _ => n.visit_mut_children_with(self),
+        };
+    }
+}
+
+impl TransformVisitor {
+    pub fn new(unresolved_mark: Mark) -> Self {
+        Self {
+            unresolved_mark,
+            export_decl_id: Default::default(),
+        }
+    }
+
+    fn exports(&self) -> Ident {
+        quote_ident!(
+            SyntaxContext::empty().apply_mark(self.unresolved_mark),
+            "exports"
+        )
+    }
+
+    /// ```JavaScript
+    /// Object.keys(_mod).forEach(function (key) {
+    ///     if (key === "default" || key === "__esModule") return;
+    ///     if (Object.prototype.hasOwnProperty.call(exports, key)) return;
+    ///     Object.defineProperty(exports, key, {
+    ///         enumerable: true,
+    ///         get: function () {
+    ///             return mod[key];
+    ///         },
+    ///         configurable: true
+    ///     });
+    /// ```
+    fn export_all(&self, id: Id) -> ModuleItem {
+        let mod_name = Ident::from(id);
+        let key = private_ident!("key");
+
+        member_expr!(Default::default(), DUMMY_SP, Object.keys)
+            .as_call(DUMMY_SP, vec![mod_name.clone().as_arg()])
+            .make_member(quote_ident!("forEach"))
+            .as_call(
+                DUMMY_SP,
+                vec![Function {
+                    params: vec![key.clone().into()],
+                    span: DUMMY_SP,
+                    body: Some(BlockStmt {
+                        stmts: vec![
+                            // if (key === "default" || key === "__esModule") return;
+                            IfStmt {
+                                span: DUMMY_SP,
+                                test: BinExpr {
+                                    span: DUMMY_SP,
+                                    op: op!("||"),
+                                    left: BinExpr {
+                                        span: DUMMY_SP,
+                                        op: op!("==="),
+                                        left: key.clone().into(),
+                                        right: quote_str!("default").into(),
+                                    }
+                                    .into(),
+                                    right: BinExpr {
+                                        span: DUMMY_SP,
+                                        op: op!("==="),
+                                        left: key.clone().into(),
+                                        right: quote_str!("__esModule").into(),
+                                    }
+                                    .into(),
+                                }
+                                .into(),
+                                cons: Box::new(
+                                    ReturnStmt {
+                                        span: DUMMY_SP,
+                                        arg: None,
+                                    }
+                                    .into(),
+                                ),
+                                alt: None,
+                            }
+                            .into(),
+                            // if (Object.prototype.hasOwnProperty.call(exports, key)) return;
+                            IfStmt {
+                                span: DUMMY_SP,
+                                test: Box::new(
+                                    member_expr!(
+                                        Default::default(),
+                                        DUMMY_SP,
+                                        Object.prototype.hasOwnProperty.call
+                                    )
+                                    .as_call(
+                                        DUMMY_SP,
+                                        vec![self.exports().as_arg(), key.clone().as_arg()],
+                                    ),
+                                ),
+                                cons: Box::new(
+                                    ReturnStmt {
+                                        span: DUMMY_SP,
+                                        arg: None,
+                                    }
+                                    .into(),
+                                ),
+                                alt: None,
+                            }
+                            .into(),
+                            // Object.defineProperty(exports, key, {
+                            //     enumerable: true,
+                            //     get: function () {
+                            //       return mod[key];
+                            //     },
+                            //     configurable: true
+                            //   });
+                            object_define_property(
+                                self.exports().as_arg(),
+                                key.clone().as_arg(),
+                                ObjectLit {
+                                    span: DUMMY_SP,
+                                    props: vec![
+                                        PropOrSpread::Prop(Box::new(
+                                            KeyValueProp {
+                                                key: quote_ident!("enumerable").into(),
+                                                value: true.into(),
+                                            }
+                                            .into(),
+                                        )),
+                                        PropOrSpread::Prop(Box::new(
+                                            KeyValueProp {
+                                                key: quote_ident!("get").into(),
+                                                value: mod_name
+                                                    .clone()
+                                                    .computed_member(key.clone())
+                                                    .into_lazy_fn(vec![])
+                                                    .into(),
+                                            }
+                                            .into(),
+                                        )),
+                                        PropOrSpread::Prop(Box::new(
+                                            KeyValueProp {
+                                                key: quote_ident!("configurable").into(),
+                                                value: true.into(),
+                                            }
+                                            .into(),
+                                        )),
+                                    ],
+                                }
+                                .as_arg(),
+                            )
+                            .into_stmt(),
+                        ],
+                        ..Default::default()
+                    }),
+                    ..Default::default()
+                }
+                .as_arg()],
+            )
+            .into_stmt()
+            .into()
+    }
+}
+
+#[plugin_transform]
+pub fn process_transform(
+    mut program: Program,
+    metadata: TransformPluginProgramMetadata,
+) -> Program {
+    program.visit_mut_with(&mut TransformVisitor::new(metadata.unresolved_mark));
+    program
+}

package/src/local_export_strip.rs

@@ -0,0 +1,362 @@
+use std::collections::BTreeMap;
+
+use rustc_hash::FxHashSet;
+use swc_core::{
+    atoms::Atom,
+    common::{util::take::Take, Span, DUMMY_SP},
+    ecma::{
+        ast::*,
+        utils::{find_pat_ids, private_ident, ExprFactory},
+        visit::{noop_visit_mut_type, VisitMut, VisitMutWith},
+    },
+};
+
+use crate::utils::{key_from_export_name, local_ident_from_export_name};
+
+pub type Export = BTreeMap<Atom, ExportItem>;
+
+#[derive(Debug)]
+pub struct ExportItem(Span, Ident);
+
+impl ExportItem {
+    pub fn new(export_name_span: Span, local_ident: Ident) -> Self {
+        Self(export_name_span, local_ident)
+    }
+
+    pub fn export_name_span(&self) -> Span {
+        self.0
+    }
+
+    pub fn into_local_ident(self) -> Ident {
+        self.1
+    }
+}
+
+#[derive(Debug, Default)]
+pub(crate) struct LocalExportStrip {
+    pub(crate) has_export_assign: bool,
+    pub(crate) export: Export,
+    pub(crate) export_all: FxHashSet<Id>,
+    pub(crate) export_decl_id: FxHashSet<Id>,
+    export_default: Option<Stmt>,
+}
+
+impl VisitMut for LocalExportStrip {
+    noop_visit_mut_type!();
+
+    fn visit_mut_script(&mut self, _: &mut Script) {
+        // skip
+    }
+
+    fn visit_mut_module(&mut self, n: &mut Module) {
+        let mut list = Vec::with_capacity(n.body.len());
+
+        for item in n.body.drain(..) {
+            match item {
+                ModuleItem::Stmt(stmt) => list.push(stmt.into()),
+
+                ModuleItem::ModuleDecl(mut module_decl) => {
+                    // collect link meta
+                    module_decl.visit_mut_with(self);
+
+                    // emit stmt
+                    match module_decl {
+                        ModuleDecl::ExportDecl(ExportDecl { decl, .. }) => {
+                            list.push(Stmt::Decl(decl).into());
+                        }
+                        ModuleDecl::ExportNamed(NamedExport { src: None, .. }) => continue,
+                        ModuleDecl::ExportNamed(
+                            item @ NamedExport {
+                                src: Some(..),
+                                type_only: false,
+                                ..
+                            },
+                        ) => {
+                            let decl: ModuleDecl = self.convert_export_decl(item).into();
+                            list.push(decl.into());
+                        }
+                        ModuleDecl::ExportAll(
+                            e @ ExportAll {
+                                type_only: false, ..
+                            },
+                        ) => {
+                            let decl: ModuleDecl = self.convert_export_all(e).into();
+                            list.push(decl.into());
+                        }
+                        ModuleDecl::ExportDefaultDecl(ExportDefaultDecl {
+                            decl:
+                                decl @ (DefaultDecl::Class(ClassExpr {
+                                    ident: Some(..), ..
+                                })
+                                | DefaultDecl::Fn(FnExpr {
+                                    ident: Some(..), ..
+                                })),
+                            ..
+                        }) => match decl {
+                            DefaultDecl::Class(class_expr) => list.extend(
+                                class_expr
+                                    .as_class_decl()
+                                    .map(|decl| Stmt::Decl(Decl::Class(decl)))
+                                    .map(Into::into),
+                            ),
+                            DefaultDecl::Fn(fn_expr) => list.extend(
+                                fn_expr
+                                    .as_fn_decl()
+                                    .map(|decl| Stmt::Decl(Decl::Fn(decl)))
+                                    .map(Into::into),
+                            ),
+                            _ => unreachable!(),
+                        },
+                        ModuleDecl::ExportDefaultExpr(..) => {
+                            list.extend(self.export_default.take().map(From::from))
+                        }
+                        ModuleDecl::TsExportAssignment(..) => {
+                            self.has_export_assign = true;
+                            list.push(module_decl.into());
+                        }
+                        _ => list.push(module_decl.into()),
+                    };
+                }
+            };
+        }
+
+        n.body = list;
+    }
+
+    /// ```javascript
+    /// export const foo = 1, bar = 2, { baz } = { baz: 3 };
+    /// export let a = 1, [b] = [2];
+    /// export function x() {}
+    /// export class y {}
+    /// ```
+    /// ->
+    /// ```javascript
+    /// const foo = 1, bar = 2, { baz } = { baz: 3 };
+    /// let a = 1, [b] = [2];
+    /// function x() {}
+    /// class y {}
+    /// ```
+    fn visit_mut_export_decl(&mut self, n: &mut ExportDecl) {
+        match &n.decl {
+            Decl::Class(ClassDecl { ident, .. }) | Decl::Fn(FnDecl { ident, .. }) => {
+                self.export.insert(
+                    ident.sym.clone(),
+                    ExportItem::new(ident.span, ident.clone()),
+                );
+            }
+
+            Decl::Var(v) => {
+                let ids = find_pat_ids::<_, Ident>(&v.decls);
+
+                self.export_decl_id.extend(ids.iter().map(Ident::to_id));
+
+                self.export.extend(
+                    find_pat_ids::<_, Ident>(&v.decls)
+                        .into_iter()
+                        .map(|id| (id.sym.clone(), ExportItem::new(id.span, id))),
+                );
+            }
+            _ => {}
+        };
+    }
+
+    /// ```javascript
+    /// export { foo, foo as bar, foo as "baz" };
+    /// export { "foo", foo as bar, "foo" as "baz" } from "mod";
+    /// export * as foo from "mod";
+    /// export * as "bar" from "mod";
+    /// ```
+    fn visit_mut_named_export(&mut self, n: &mut NamedExport) {
+        if n.type_only || n.src.is_some() {
+            return;
+        }
+
+        let NamedExport { specifiers, .. } = n.take();
+
+        self.export.extend(specifiers.into_iter().map(|e| match e {
+            ExportSpecifier::Namespace(..) => {
+                unreachable!("`export *` without src is invalid")
+            }
+            ExportSpecifier::Default(..) => {
+                unreachable!("`export foo` without src is invalid")
+            }
+            ExportSpecifier::Named(ExportNamedSpecifier { orig, exported, .. }) => {
+                let orig = match orig {
+                    ModuleExportName::Ident(id) => id,
+                    ModuleExportName::Str(_) => {
+                        unreachable!(r#"`export {{ "foo" }}` without src is invalid"#)
+                    }
+                };
+
+                if let Some(exported) = exported {
+                    let (export_name, export_name_span) = match exported {
+                        ModuleExportName::Ident(Ident { span, sym, .. }) => (sym, span),
+                        ModuleExportName::Str(Str { span, value, .. }) => (value, span),
+                    };
+
+                    (export_name, ExportItem::new(export_name_span, orig))
+                } else {
+                    (orig.sym.clone(), ExportItem::new(orig.span, orig))
+                }
+            }
+        }))
+    }
+
+    /// ```javascript
+    /// export default class foo {};
+    /// export default class {};
+    /// export default function bar () {};
+    /// export default function () {};
+    /// ```
+    /// ->
+    /// ```javascript
+    /// class foo {};
+    /// class _default {};
+    /// function bar () {};
+    /// function _default () {};
+    /// ```
+    fn visit_mut_export_default_decl(&mut self, n: &mut ExportDefaultDecl) {
+        match &mut n.decl {
+            DefaultDecl::Class(class_expr) => {
+                if let Some(ident) = class_expr.ident.clone() {
+                    self.export
+                        .insert("default".into(), ExportItem::new(n.span, ident));
+                }
+            }
+            DefaultDecl::Fn(fn_expr) => {
+                if let Some(ident) = fn_expr.ident.clone() {
+                    self.export
+                        .insert("default".into(), ExportItem::new(n.span, ident));
+                }
+            }
+            DefaultDecl::TsInterfaceDecl(_) => {}
+        }
+    }
+
+    /// ```javascript
+    /// export default foo;
+    /// export default 1
+    /// ```
+    /// ->
+    /// ```javascript
+    /// var _default = foo;
+    /// var _default = 1;
+    /// ```
+    fn visit_mut_export_default_expr(&mut self, n: &mut ExportDefaultExpr) {
+        let ident = private_ident!(n.span, "_default");
+
+        self.export
+            .insert("default".into(), ExportItem::new(n.span, ident.clone()));
+
+        self.export_default = Some(Stmt::Decl(
+            n.expr
+                .take()
+                .into_var_decl(VarDeclKind::Const, ident.into())
+                .into(),
+        ));
+    }
+}
+
+impl LocalExportStrip {
+    fn convert_export_decl(&mut self, n: NamedExport) -> ImportDecl {
+        let NamedExport {
+            span,
+            specifiers,
+            src,
+            type_only,
+            with,
+        } = n;
+
+        let src = src.unwrap();
+
+        let specifiers = specifiers
+            .into_iter()
+            .flat_map(|s| self.convert_export_specifier(s))
+            .collect();
+
+        ImportDecl {
+            span,
+            specifiers,
+            src,
+            type_only,
+            with,
+            phase: Default::default(),
+        }
+    }
+
+    fn convert_export_specifier(&mut self, s: ExportSpecifier) -> Option<ImportSpecifier> {
+        match s {
+            ExportSpecifier::Namespace(ExportNamespaceSpecifier { span, name }) => {
+                let (export_name, export_span) = key_from_export_name(&name);
+                let local = local_ident_from_export_name(name);
+                self.export
+                    .insert(export_name, ExportItem::new(export_span, local.clone()));
+
+                Some(ImportSpecifier::Namespace(ImportStarAsSpecifier {
+                    span,
+                    local,
+                }))
+            }
+            ExportSpecifier::Default(ExportDefaultSpecifier { exported }) => {
+                let (export_name, export_span) = (exported.sym.clone(), exported.span);
+                let local = exported.into_private();
+                self.export
+                    .insert(export_name, ExportItem::new(export_span, local.clone()));
+
+                Some(ImportSpecifier::Default(ImportDefaultSpecifier {
+                    local,
+                    span: DUMMY_SP,
+                }))
+            }
+            ExportSpecifier::Named(ExportNamedSpecifier {
+                span,
+                orig,
+                exported,
+                is_type_only: false,
+            }) => {
+                // export { "x-1" as "y-1" } from "foo"
+                // ->
+                // import { "x-1" as x1 } from "foo"
+                // export { x1 as "y-1" }
+                let name = exported.as_ref().unwrap_or(&orig);
+
+                let (export_name, export_span) = key_from_export_name(name);
+                let local = local_ident_from_export_name(orig.clone());
+                self.export
+                    .insert(export_name, ExportItem::new(export_span, local.clone()));
+
+                Some(ImportSpecifier::Named(ImportNamedSpecifier {
+                    span,
+                    local,
+                    imported: Some(orig),
+                    is_type_only: false,
+                }))
+            }
+            _ => None,
+        }
+    }
+
+    fn convert_export_all(&mut self, e: ExportAll) -> ImportDecl {
+        let ExportAll {
+            span, src, with, ..
+        } = e;
+
+        let mod_name = private_ident!("mod");
+
+        self.export_all.insert(mod_name.to_id());
+
+        let star = ImportStarAsSpecifier {
+            span,
+            local: mod_name.clone(),
+        };
+
+        ImportDecl {
+            span,
+            specifiers: vec![star.into()],
+            src,
+            type_only: false,
+            with,
+            phase: Default::default(),
+        }
+    }
+}

package/src/utils.rs

@@ -0,0 +1,143 @@
+use swc_core::{
+    atoms::Atom,
+    common::{Span, DUMMY_SP},
+    ecma::{
+        ast::*,
+        utils::{member_expr, private_ident, quote_ident, quote_str, ExprFactory},
+    },
+};
+
+use crate::local_export_strip::Export;
+
+/// ```javascript
+/// {
+///     get() { return ident; }
+/// }
+/// ```
+pub(crate) fn prop_method_getter(ident: Ident) -> Prop {
+    let key = quote_ident!("get").into();
+
+    MethodProp {
+        key,
+        function: ident.into_lazy_fn(Default::default()).into(),
+    }
+    .into()
+}
+
+/// ```javascript
+/// {
+///     set(v) { ident = v; }
+/// }
+/// ```
+pub(crate) fn prop_method_setter(ident: Ident) -> Prop {
+    let key = quote_ident!("set").into();
+
+    let setter_param = private_ident!("v");
+    let params = vec![setter_param.clone().into()];
+
+    let body = BlockStmt {
+        stmts: vec![setter_param
+            .make_assign_to(op!("="), ident.clone().into())
+            .into_stmt()],
+        ..Default::default()
+    };
+
+    MethodProp {
+        key,
+        function: Function {
+            params,
+            body: Some(body),
+            ..Default::default()
+        }
+        .into(),
+    }
+    .into()
+}
+
+/// Creates
+///
+///```js
+/// 
+///  Object.defineProperty(target, prop_name, {
+///      ...props
+///  });
+/// ```
+pub(super) fn object_define_property(
+    target: ExprOrSpread,
+    prop_name: ExprOrSpread,
+    descriptor: ExprOrSpread,
+) -> Expr {
+    member_expr!(Default::default(), DUMMY_SP, Object.defineProperty)
+        .as_call(DUMMY_SP, vec![target, prop_name, descriptor])
+}
+
+pub(crate) fn object_define_enumerable_configurable(
+    target: ExprOrSpread,
+    prop_name: ExprOrSpread,
+    getter: PropOrSpread,
+    setter: PropOrSpread,
+) -> Expr {
+    object_define_property(
+        target,
+        prop_name,
+        ObjectLit {
+            span: DUMMY_SP,
+            props: vec![
+                PropOrSpread::Prop(Box::new(
+                    KeyValueProp {
+                        key: quote_ident!("enumerable").into(),
+                        value: Box::new(true.into()),
+                    }
+                    .into(),
+                )),
+                getter,
+                setter,
+                PropOrSpread::Prop(Box::new(
+                    KeyValueProp {
+                        key: quote_ident!("configurable").into(),
+                        value: Box::new(true.into()),
+                    }
+                    .into(),
+                )),
+            ],
+        }
+        .as_arg(),
+    )
+}
+
+pub(crate) fn emit_export_stmts(exports: Ident, export: Export) -> Vec<Stmt> {
+    export
+        .into_iter()
+        .map(|(export_name, export_item)| {
+            let prop_name = quote_str!(export_item.export_name_span(), export_name);
+            let local_ident = export_item.into_local_ident();
+
+            object_define_enumerable_configurable(
+                exports.clone().as_arg(),
+                prop_name.as_arg(),
+                prop_method_getter(local_ident.clone()).into(),
+                prop_method_setter(local_ident).into(),
+            )
+            .into_stmt()
+        })
+        .collect()
+}
+
+pub(crate) fn key_from_export_name(n: &ModuleExportName) -> (Atom, Span) {
+    match n {
+        ModuleExportName::Ident(ident) => (ident.sym.clone(), ident.span),
+        ModuleExportName::Str(str) => (str.value.clone(), str.span),
+    }
+}
+
+pub(crate) fn local_ident_from_export_name(n: ModuleExportName) -> Ident {
+    let name = match n {
+        ModuleExportName::Ident(ident) => ident.sym,
+        ModuleExportName::Str(str) => str.value,
+    };
+
+    match Ident::verify_symbol(&name) {
+        Ok(_) => private_ident!(name),
+        Err(s) => private_ident!(s),
+    }
+}