dismantle 0.2.2 → 0.3.0

package/dist/cjs/development/index.cjs

@@ -36,8 +36,8 @@ module.exports = __toCommonJS(src_exports);
 var babel = __toESM(require("@babel/core"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
 
-// src/split.ts
-var t6 = __toESM(require("@babel/types"), 1);
+// src/split-block-directive.ts
+var t9 = __toESM(require("@babel/types"), 1);
 
 // src/hidden-imports.ts
 var HIDDEN_FUNC = {
@@ -51,11 +51,22 @@ var HIDDEN_GENERATOR = {
   name: "$$gen"
 };
 
-// src/utils/assert.ts
-function assert(cond, error) {
-  if (!cond) {
-    throw new Error(error);
-  }
+// src/split.ts
+var t7 = __toESM(require("@babel/types"), 1);
+
+// src/utils/generate-unique-name.ts
+var t = __toESM(require("@babel/types"), 1);
+function generateUniqueName(path2, name) {
+  let uid;
+  let i = 1;
+  do {
+    uid = name + "_" + i;
+    i++;
+  } while (path2.scope.hasLabel(uid) || path2.scope.hasBinding(uid) || path2.scope.hasGlobal(uid) || path2.scope.hasReference(uid));
+  const program2 = path2.scope.getProgramParent();
+  program2.references[uid] = true;
+  program2.uids[uid] = true;
+  return t.identifier(uid);
 }
 
 // src/utils/generator-shim.ts
@@ -112,7 +123,7 @@ function getDescriptiveName(path2, defaultName) {
 }
 
 // src/utils/get-foreign-bindings.ts
-var t = __toESM(require("@babel/types"), 1);
+var t2 = __toESM(require("@babel/types"), 1);
 function isForeignBinding(source, current, name, mode) {
   if (current.scope.hasGlobal(name)) {
     return false;
@@ -135,7 +146,7 @@ function isForeignBinding(source, current, name, mode) {
 function isInTypescript(path2) {
   let parent = path2.parentPath;
   while (parent) {
-    if (t.isTypeScript(parent.node) && !t.isExpression(parent.node)) {
+    if (t2.isTypeScript(parent.node) && !t2.isExpression(parent.node)) {
       return true;
     }
     parent = parent.parentPath;
@@ -155,7 +166,7 @@ function getForeignBindings(path2, mode) {
 }
 
 // src/utils/get-identifiers-from-lval.ts
-var t2 = __toESM(require("@babel/types"), 1);
+var t3 = __toESM(require("@babel/types"), 1);
 function getIdentifiersFromArrayPattern(node) {
   const ids = [];
   for (let i = 0, len = node.elements.length; i < len; i++) {
@@ -173,7 +184,7 @@ function getIdentifiersFromObjectPattern(node) {
     if (el) {
       if (el.type === "RestElement") {
         ids.push(...getIdentifiersFromLVal(el));
-      } else if (t2.isLVal(el.value)) {
+      } else if (t3.isLVal(el.value)) {
         ids.push(...getIdentifiersFromLVal(el.value));
       }
     }
@@ -197,44 +208,16 @@ function getIdentifiersFromLVal(node) {
   }
 }
 
-// src/utils/get-import-identifier.ts
-var t3 = __toESM(require("@babel/types"), 1);
-function getImportIdentifier(state, path2, registration) {
-  const name = registration.kind === "named" ? registration.name : "default";
-  const target = `${registration.source}[${name}]`;
-  const current = state.imports.get(target);
-  if (current) {
-    return current;
-  }
-  const programParent = path2.scope.getProgramParent();
-  const uid = programParent.generateUidIdentifier(
-    registration.kind === "named" ? registration.name : "default"
-  );
-  const newPath = programParent.path.unshiftContainer(
-    "body",
-    t3.importDeclaration(
-      [
-        registration.kind === "named" ? t3.importSpecifier(uid, t3.identifier(registration.name)) : t3.importDefaultSpecifier(uid)
-      ],
-      t3.stringLiteral(registration.source)
-    )
-  )[0];
-  programParent.registerDeclaration(newPath);
-  state.imports.set(target, uid);
-  return uid;
-}
-
 // src/utils/get-module-definition.ts
-var t4 = __toESM(require("@babel/types"), 1);
+var t5 = __toESM(require("@babel/types"), 1);
 
 // src/utils/get-import-specifier-name.ts
+var t4 = __toESM(require("@babel/types"), 1);
 function getImportSpecifierName(node) {
-  switch (node.imported.type) {
-    case "Identifier":
-      return node.imported.name;
-    case "StringLiteral":
-      return node.imported.value;
+  if (t4.isIdentifier(node.imported)) {
+    return node.imported.name;
   }
+  return node.imported.value;
 }
 
 // src/utils/unwrap.ts
@@ -276,7 +259,7 @@ function unwrapPath(path2, key) {
 
 // src/utils/get-module-definition.ts
 function getModuleDefinition(path2) {
-  if (!(isPathValid(path2, t4.isImportSpecifier) || isPathValid(path2, t4.isImportDefaultSpecifier) || isPathValid(path2, t4.isImportNamespaceSpecifier))) {
+  if (!(isPathValid(path2, t5.isImportSpecifier) || isPathValid(path2, t5.isImportDefaultSpecifier) || isPathValid(path2, t5.isImportNamespaceSpecifier))) {
     return void 0;
   }
   const parent = path2.getStatementParent();
@@ -315,12 +298,12 @@ function getModuleDefinition(path2) {
 }
 
 // src/utils/get-root-statement-path.ts
-var t5 = __toESM(require("@babel/types"), 1);
+var t6 = __toESM(require("@babel/types"), 1);
 function getRootStatementPath(path2) {
   let current = path2.parentPath;
   while (current) {
     const next = current.parentPath;
-    if (next && t5.isProgram(next.node)) {
+    if (next && t6.isProgram(next.node)) {
       return current;
     }
     current = next;
@@ -332,20 +315,20 @@ function getRootStatementPath(path2) {
 function moduleDefinitionToImportSpecifier(definition) {
   switch (definition.kind) {
     case "default":
-      return t6.importDefaultSpecifier(t6.identifier(definition.local));
+      return t7.importDefaultSpecifier(t7.identifier(definition.local));
     case "named":
-      return t6.importSpecifier(
-        t6.identifier(definition.local),
-        definition.imported ? t6.identifier(definition.imported) : t6.identifier(definition.local)
+      return t7.importSpecifier(
+        t7.identifier(definition.local),
+        definition.imported ? t7.identifier(definition.imported) : t7.identifier(definition.local)
       );
     case "namespace":
-      return t6.importNamespaceSpecifier(t6.identifier(definition.local));
+      return t7.importNamespaceSpecifier(t7.identifier(definition.local));
   }
 }
 function moduleDefinitionToImportDeclaration(definition) {
-  return t6.importDeclaration(
+  return t7.importDeclaration(
     [moduleDefinitionToImportSpecifier(definition)],
-    t6.stringLiteral(definition.source)
+    t7.stringLiteral(definition.source)
   );
 }
 function moduleDefinitionsToImportDeclarations(definitions) {
@@ -373,13 +356,13 @@ function registerModuleLevelBinding(ctx, modules, binding, target) {
   const current = ctx.bindings.get(binding);
   if (current) {
     modules.push(current);
-  } else if (isPathValid(target.path, t6.isVariableDeclarator)) {
+  } else if (isPathValid(target.path, t7.isVariableDeclarator)) {
     const definitions = splitVariableDeclarator(ctx, target.path);
     for (let k = 0, klen = definitions.length; k < klen; k++) {
       modules.push(definitions[k]);
       ctx.bindings.set(definitions[k].local, definitions[k]);
     }
-  } else if (isPathValid(target.path, t6.isFunctionDeclaration)) {
+  } else if (isPathValid(target.path, t7.isFunctionDeclaration)) {
     const definition = splitFunctionDeclaration(ctx, target.path);
     modules.push(definition);
     ctx.bindings.set(definition.local, definition);
@@ -432,9 +415,9 @@ function createRootFile(ctx, bindings, replacement) {
   const rootFile = createVirtualFileName(ctx);
   const rootContent = generateCode(
     ctx.id,
-    t6.program([
+    t7.program([
       ...ctx.options.mode === "server" ? moduleDefinitionsToImportDeclarations(bindings.modules) : [],
-      t6.exportDefaultDeclaration(replacement)
+      t7.exportDefaultDeclaration(replacement)
     ])
   );
   ctx.onVirtualFile(
@@ -449,7 +432,7 @@ function createEntryFile(ctx, path2, rootFile, imported) {
   if (ctx.options.env !== "production") {
     id += `-${getDescriptiveName(path2, "anonymous")}`;
   }
-  const entryID = path2.scope.generateUidIdentifier("entry");
+  const entryID = generateUniqueName(path2, "entry");
   const entryImports = [
     {
       kind: imported.kind,
@@ -458,9 +441,9 @@ function createEntryFile(ctx, path2, rootFile, imported) {
       imported: imported.kind === "named" ? imported.name : void 0
     }
   ];
-  const args = [t6.stringLiteral(id)];
-  if (ctx.options.mode === "server") {
-    const rootID = path2.scope.generateUidIdentifier("root");
+  const args = [t7.stringLiteral(id)];
+  if (rootFile) {
+    const rootID = generateUniqueName(path2, "root");
     entryImports.push({
       kind: "default",
       source: rootFile,
@@ -471,9 +454,9 @@ function createEntryFile(ctx, path2, rootFile, imported) {
   const entryFile = createVirtualFileName(ctx);
   const entryContent = generateCode(
     ctx.id,
-    t6.program([
+    t7.program([
       ...moduleDefinitionsToImportDeclarations(entryImports),
-      t6.exportDefaultDeclaration(t6.callExpression(entryID, args))
+      t7.exportDefaultDeclaration(t7.callExpression(entryID, args))
     ])
   );
   ctx.onVirtualFile(
@@ -489,17 +472,17 @@ function splitFunctionDeclaration(ctx, path2) {
   const file = createVirtualFileName(ctx);
   const compiled = generateCode(
     ctx.id,
-    t6.program([
+    t7.program([
       ...moduleDefinitionsToImportDeclarations(modules),
-      t6.exportNamedDeclaration(path2.node)
+      t7.exportNamedDeclaration(path2.node)
     ])
   );
   ctx.onVirtualFile(file, { code: compiled.code, map: compiled.map }, "none");
   const statement = getRootStatementPath(path2);
-  const identifier3 = path2.node.id || path2.scope.generateUidIdentifier("func");
+  const identifier7 = path2.node.id || generateUniqueName(path2, "func");
   const definition = {
     kind: "named",
-    local: identifier3.name,
+    local: identifier7.name,
     source: file
   };
   statement.insertBefore(moduleDefinitionToImportDeclaration(definition));
@@ -507,22 +490,22 @@ function splitFunctionDeclaration(ctx, path2) {
   return definition;
 }
 function splitVariableDeclarator(ctx, path2) {
-  const init = unwrapPath(path2.get("init"), t6.isExpression);
+  const init = unwrapPath(path2.get("init"), t7.isExpression);
   const modules = init ? extractBindings(
     ctx,
     path2,
     getForeignBindings(
       path2,
-      isPathValid(init, t6.isArrowFunctionExpression) || isPathValid(init, t6.isFunctionExpression) ? "function" : "expression"
+      isPathValid(init, t7.isArrowFunctionExpression) || isPathValid(init, t7.isFunctionExpression) ? "function" : "expression"
     )
   ).modules : [];
   const file = createVirtualFileName(ctx);
   const parent = path2.parentPath.node;
   const compiled = generateCode(
     ctx.id,
-    t6.program([
+    t7.program([
       ...moduleDefinitionsToImportDeclarations(modules),
-      t6.exportNamedDeclaration(t6.variableDeclaration(parent.kind, [path2.node]))
+      t7.exportNamedDeclaration(t7.variableDeclaration(parent.kind, [path2.node]))
     ])
   );
   ctx.onVirtualFile(file, { code: compiled.code, map: compiled.map }, "none");
@@ -540,12 +523,91 @@ function splitVariableDeclarator(ctx, path2) {
   path2.remove();
   return definitions;
 }
-var BREAK_KEY = t6.numericLiteral(0);
-var CONTINUE_KEY = t6.numericLiteral(1);
-var RETURN_KEY = t6.numericLiteral(2);
-var NO_HALT_KEY = t6.numericLiteral(3);
-var THROW_KEY = t6.numericLiteral(4);
-var YIELD_KEY = t6.numericLiteral(5);
+var BREAK_KEY = t7.numericLiteral(0);
+var CONTINUE_KEY = t7.numericLiteral(1);
+var RETURN_KEY = t7.numericLiteral(2);
+var NO_HALT_KEY = t7.numericLiteral(3);
+var THROW_KEY = t7.numericLiteral(4);
+var YIELD_KEY = t7.numericLiteral(5);
+function getGeneratorReplacementForBlock(path2, registerID, args) {
+  const iterator = generateUniqueName(path2, "iterator");
+  const step = generateUniqueName(path2, "step");
+  const replacement = [
+    t7.variableDeclaration("let", [
+      t7.variableDeclarator(step),
+      // First, get the iterator by calling the generator
+      t7.variableDeclarator(
+        iterator,
+        t7.awaitExpression(t7.callExpression(registerID, args))
+      )
+    ]),
+    // Create a while statement, the intent is to
+    // repeatedly iterate the generator
+    t7.whileStatement(
+      t7.booleanLiteral(true),
+      t7.blockStatement([
+        // Get the next value
+        t7.expressionStatement(
+          t7.assignmentExpression(
+            "=",
+            step,
+            t7.awaitExpression(
+              t7.callExpression(
+                t7.memberExpression(iterator, t7.identifier("next")),
+                []
+              )
+            )
+          )
+        ),
+        // Check if the step is done
+        t7.ifStatement(
+          t7.memberExpression(step, t7.identifier("done")),
+          t7.blockStatement([
+            // exit the loop
+            t7.breakStatement()
+          ]),
+          // Otherwise, yield the value
+          t7.blockStatement([
+            t7.expressionStatement(
+              t7.yieldExpression(
+                t7.memberExpression(step, t7.identifier("value"))
+              )
+            )
+          ])
+        )
+      ])
+    )
+  ];
+  return [replacement, step];
+}
+
+// src/utils/get-import-identifier.ts
+var t8 = __toESM(require("@babel/types"), 1);
+function getImportIdentifier(state, path2, registration) {
+  const name = registration.kind === "named" ? registration.name : "default";
+  const target = `${registration.source}[${name}]`;
+  const current = state.imports.get(target);
+  if (current) {
+    return current;
+  }
+  const programParent = path2.scope.getProgramParent();
+  const uid = generateUniqueName(programParent.path, name);
+  programParent.registerDeclaration(
+    programParent.path.unshiftContainer(
+      "body",
+      t8.importDeclaration(
+        [
+          registration.kind === "named" ? t8.importSpecifier(uid, t8.identifier(registration.name)) : t8.importDefaultSpecifier(uid)
+        ],
+        t8.stringLiteral(registration.source)
+      )
+    )[0]
+  );
+  state.imports.set(target, uid);
+  return uid;
+}
+
+// src/split-block-directive.ts
 function transformBlockContent(path2, mutations) {
   const target = path2.scope.getFunctionParent() || path2.scope.getProgramParent();
   const breaks = [];
@@ -554,7 +616,7 @@ function transformBlockContent(path2, mutations) {
   let continueCount = 0;
   let hasReturn = false;
   let hasYield = false;
-  const applyMutations = mutations.length ? path2.scope.generateUidIdentifier("mutate") : void 0;
+  const applyMutations = mutations.length ? generateUniqueName(path2, "mutate") : void 0;
   path2.traverse({
     BreakStatement(child) {
       const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
@@ -564,14 +626,14 @@ function transformBlockContent(path2, mutations) {
         if (child.node.label) {
           const targetName = child.node.label.name;
           breaks.push(targetName);
-          replacement.push(t6.stringLiteral(targetName));
+          replacement.push(t9.stringLiteral(targetName));
         } else {
-          replacement.push(t6.nullLiteral());
+          replacement.push(t9.nullLiteral());
         }
         if (applyMutations) {
-          replacement.push(t6.callExpression(applyMutations, []));
+          replacement.push(t9.callExpression(applyMutations, []));
         }
-        child.replaceWith(t6.returnStatement(t6.arrayExpression(replacement)));
+        child.replaceWith(t9.returnStatement(t9.arrayExpression(replacement)));
         child.skip();
       }
     },
@@ -583,14 +645,14 @@ function transformBlockContent(path2, mutations) {
         if (child.node.label) {
           const targetName = child.node.label.name;
           continues.push(targetName);
-          replacement.push(t6.stringLiteral(targetName));
+          replacement.push(t9.stringLiteral(targetName));
         } else {
-          replacement.push(t6.nullLiteral());
+          replacement.push(t9.nullLiteral());
         }
         if (applyMutations) {
-          replacement.push(t6.callExpression(applyMutations, []));
+          replacement.push(t9.callExpression(applyMutations, []));
         }
-        child.replaceWith(t6.returnStatement(t6.arrayExpression(replacement)));
+        child.replaceWith(t9.returnStatement(t9.arrayExpression(replacement)));
         child.skip();
       }
     },
@@ -600,10 +662,10 @@ function transformBlockContent(path2, mutations) {
         hasReturn = true;
         const arg = child.get("argument");
         arg.replaceWith(
-          t6.arrayExpression([
+          t9.arrayExpression([
             RETURN_KEY,
-            arg.node ? arg.node : t6.nullLiteral(),
-            applyMutations ? t6.callExpression(applyMutations, []) : t6.nullLiteral()
+            arg.node ? arg.node : t9.nullLiteral(),
+            applyMutations ? t9.callExpression(applyMutations, []) : t9.nullLiteral()
           ])
         );
       }
@@ -616,43 +678,43 @@ function transformBlockContent(path2, mutations) {
         } else {
           const arg = child.get("argument");
           arg.replaceWith(
-            t6.arrayExpression([
+            t9.arrayExpression([
               YIELD_KEY,
-              arg.node ? arg.node : t6.nullLiteral(),
-              applyMutations ? t6.callExpression(applyMutations, []) : t6.nullLiteral()
+              arg.node ? arg.node : t9.nullLiteral(),
+              applyMutations ? t9.callExpression(applyMutations, []) : t9.nullLiteral()
             ])
           );
         }
       }
     }
   });
-  const error = path2.scope.generateUidIdentifier("error");
+  const error = generateUniqueName(path2, "error");
   const throwResult = [THROW_KEY, error];
   const haltResult = [NO_HALT_KEY];
   if (applyMutations) {
-    throwResult.push(t6.callExpression(applyMutations, []));
-    haltResult.push(t6.nullLiteral());
-    haltResult.push(t6.callExpression(applyMutations, []));
+    throwResult.push(t9.callExpression(applyMutations, []));
+    haltResult.push(t9.nullLiteral());
+    haltResult.push(t9.callExpression(applyMutations, []));
   }
   const statements = [
-    t6.tryStatement(
-      t6.blockStatement(path2.node.body),
-      t6.catchClause(
+    t9.tryStatement(
+      t9.blockStatement(path2.node.body),
+      t9.catchClause(
         error,
-        t6.blockStatement([t6.returnStatement(t6.arrayExpression(throwResult))])
+        t9.blockStatement([t9.returnStatement(t9.arrayExpression(throwResult))])
       )
     ),
-    t6.returnStatement(t6.arrayExpression(haltResult))
+    t9.returnStatement(t9.arrayExpression(haltResult))
   ];
   if (applyMutations) {
     statements.unshift(
-      t6.variableDeclaration("const", [
-        t6.variableDeclarator(
+      t9.variableDeclaration("const", [
+        t9.variableDeclarator(
           applyMutations,
-          t6.arrowFunctionExpression(
+          t9.arrowFunctionExpression(
             [],
-            t6.objectExpression(
-              mutations.map((item) => t6.objectProperty(item, item, false, true))
+            t9.objectExpression(
+              mutations.map((item) => t9.objectProperty(item, item, false, true))
             )
           )
         )
@@ -665,21 +727,21 @@ function transformBlockContent(path2, mutations) {
 function getBreakCheck(returnType, returnResult, breakCount, breaks, check) {
   let current;
   if (breakCount !== breaks.length) {
-    current = t6.blockStatement([t6.breakStatement()]);
+    current = t9.blockStatement([t9.breakStatement()]);
   }
   for (let i = 0, len = breaks.length; i < len; i++) {
     const target = breaks[i];
-    current = t6.blockStatement([
-      t6.ifStatement(
-        t6.binaryExpression("===", returnResult, t6.stringLiteral(target)),
-        t6.blockStatement([t6.breakStatement(t6.identifier(target))]),
+    current = t9.blockStatement([
+      t9.ifStatement(
+        t9.binaryExpression("===", returnResult, t9.stringLiteral(target)),
+        t9.blockStatement([t9.breakStatement(t9.identifier(target))]),
         current
       )
     ]);
   }
   if (current) {
-    return t6.ifStatement(
-      t6.binaryExpression("===", returnType, BREAK_KEY),
+    return t9.ifStatement(
+      t9.binaryExpression("===", returnType, BREAK_KEY),
       current,
       check
     );
@@ -689,87 +751,36 @@ function getBreakCheck(returnType, returnResult, breakCount, breaks, check) {
 function getContinueCheck(returnType, returnResult, continueCount, continues, check) {
   let current;
   if (continueCount !== continues.length) {
-    current = t6.blockStatement([t6.continueStatement()]);
+    current = t9.blockStatement([t9.continueStatement()]);
   }
   for (let i = 0, len = continues.length; i < len; i++) {
     const target = continues[i];
-    current = t6.blockStatement([
-      t6.ifStatement(
-        t6.binaryExpression("===", returnResult, t6.stringLiteral(target)),
-        t6.blockStatement([t6.continueStatement(t6.identifier(target))]),
+    current = t9.blockStatement([
+      t9.ifStatement(
+        t9.binaryExpression("===", returnResult, t9.stringLiteral(target)),
+        t9.blockStatement([t9.continueStatement(t9.identifier(target))]),
         current
       )
     ]);
   }
   if (current) {
-    return t6.ifStatement(
-      t6.binaryExpression("===", returnType, CONTINUE_KEY),
+    return t9.ifStatement(
+      t9.binaryExpression("===", returnType, CONTINUE_KEY),
       current,
       check
     );
   }
   return check;
 }
-function getGeneratorReplacementForServerBlock(path2, registerID, args) {
-  const iterator = path2.scope.generateUidIdentifier("iterator");
-  const step = path2.scope.generateUidIdentifier("step");
-  const replacement = [
-    t6.variableDeclaration("let", [
-      t6.variableDeclarator(step),
-      // First, get the iterator by calling the generator
-      t6.variableDeclarator(
-        iterator,
-        t6.awaitExpression(t6.callExpression(registerID, args))
-      )
-    ]),
-    // Create a while statement, the intent is to
-    // repeatedly iterate the generator
-    t6.whileStatement(
-      t6.booleanLiteral(true),
-      t6.blockStatement([
-        // Get the next value
-        t6.expressionStatement(
-          t6.assignmentExpression(
-            "=",
-            step,
-            t6.awaitExpression(
-              t6.callExpression(
-                t6.memberExpression(iterator, t6.identifier("next")),
-                []
-              )
-            )
-          )
-        ),
-        // Check if the step is done
-        t6.ifStatement(
-          t6.memberExpression(step, t6.identifier("done")),
-          t6.blockStatement([
-            // exit the loop
-            t6.breakStatement()
-          ]),
-          // Otherwise, yield the value
-          t6.blockStatement([
-            t6.expressionStatement(
-              t6.yieldExpression(
-                t6.memberExpression(step, t6.identifier("value"))
-              )
-            )
-          ])
-        )
-      ])
-    )
-  ];
-  return [replacement, step];
-}
-function getBlockReplacement(ctx, path2, entryFile, bindings, halting) {
-  const returnType = path2.scope.generateUidIdentifier("type");
-  const returnResult = path2.scope.generateUidIdentifier("result");
-  const returnMutations = path2.scope.generateUidIdentifier("mutations");
+function getBlockDirectiveReplacement(ctx, path2, entryFile, bindings, halting) {
+  const returnType = generateUniqueName(path2, "type");
+  const returnResult = generateUniqueName(path2, "result");
+  const returnMutations = generateUniqueName(path2, "mutations");
   let check;
   if (halting.hasReturn) {
-    check = t6.ifStatement(
-      t6.binaryExpression("===", returnType, RETURN_KEY),
-      t6.blockStatement([t6.returnStatement(returnResult)]),
+    check = t9.ifStatement(
+      t9.binaryExpression("===", returnType, RETURN_KEY),
+      t9.blockStatement([t9.returnStatement(returnResult)]),
       check
     );
   }
@@ -793,33 +804,33 @@ function getBlockReplacement(ctx, path2, entryFile, bindings, halting) {
   }
   const replacement = [];
   if (halting.hasYield) {
-    const blockID = path2.scope.generateUidIdentifier("block");
+    const blockID = generateUniqueName(path2, "block");
     replacement.push(
-      t6.variableDeclaration("const", [
-        t6.variableDeclarator(
+      t9.variableDeclaration("const", [
+        t9.variableDeclarator(
           blockID,
-          t6.callExpression(getImportIdentifier(ctx, path2, HIDDEN_GENERATOR), [
-            t6.memberExpression(
-              t6.awaitExpression(t6.importExpression(t6.stringLiteral(entryFile))),
-              t6.identifier("default")
+          t9.callExpression(getImportIdentifier(ctx, path2, HIDDEN_GENERATOR), [
+            t9.memberExpression(
+              t9.awaitExpression(t9.importExpression(t9.stringLiteral(entryFile))),
+              t9.identifier("default")
             ),
-            bindings.mutations.length ? t6.arrowFunctionExpression(
+            bindings.mutations.length ? t9.arrowFunctionExpression(
               [returnMutations],
-              t6.assignmentExpression(
+              t9.assignmentExpression(
                 "=",
-                t6.objectPattern(
+                t9.objectPattern(
                   bindings.mutations.map(
-                    (item) => t6.objectProperty(item, item, false, true)
+                    (item) => t9.objectProperty(item, item, false, true)
                   )
                 ),
                 returnMutations
               )
-            ) : t6.nullLiteral()
+            ) : t9.nullLiteral()
           ])
         )
       ])
     );
-    const [reps, step] = getGeneratorReplacementForServerBlock(
+    const [reps, step] = getGeneratorReplacementForBlock(
       path2,
       blockID,
       bindings.locals
@@ -828,39 +839,39 @@ function getBlockReplacement(ctx, path2, entryFile, bindings, halting) {
       replacement.push(reps[i]);
     }
     replacement.push(
-      t6.variableDeclaration("const", [
-        t6.variableDeclarator(
-          t6.arrayPattern([returnType, returnResult]),
-          t6.memberExpression(step, t6.identifier("value"))
+      t9.variableDeclaration("const", [
+        t9.variableDeclarator(
+          t9.arrayPattern([returnType, returnResult]),
+          t9.memberExpression(step, t9.identifier("value"))
         )
       ])
     );
   } else {
     replacement.push(
-      t6.variableDeclaration("const", [
-        t6.variableDeclarator(
-          t6.arrayPattern([returnType, returnResult]),
-          t6.awaitExpression(
-            t6.callExpression(
-              t6.callExpression(getImportIdentifier(ctx, path2, HIDDEN_FUNC), [
-                t6.memberExpression(
-                  t6.awaitExpression(
-                    t6.importExpression(t6.stringLiteral(entryFile))
+      t9.variableDeclaration("const", [
+        t9.variableDeclarator(
+          t9.arrayPattern([returnType, returnResult]),
+          t9.awaitExpression(
+            t9.callExpression(
+              t9.callExpression(getImportIdentifier(ctx, path2, HIDDEN_FUNC), [
+                t9.memberExpression(
+                  t9.awaitExpression(
+                    t9.importExpression(t9.stringLiteral(entryFile))
                   ),
-                  t6.identifier("default")
+                  t9.identifier("default")
                 ),
-                bindings.mutations.length ? t6.arrowFunctionExpression(
+                bindings.mutations.length ? t9.arrowFunctionExpression(
                   [returnMutations],
-                  t6.assignmentExpression(
+                  t9.assignmentExpression(
                     "=",
-                    t6.objectPattern(
+                    t9.objectPattern(
                       bindings.mutations.map(
-                        (item) => t6.objectProperty(item, item, false, true)
+                        (item) => t9.objectProperty(item, item, false, true)
                       )
                     ),
                     returnMutations
                   )
-                ) : t6.nullLiteral()
+                ) : t9.nullLiteral()
               ]),
               bindings.locals
             )
@@ -872,28 +883,32 @@ function getBlockReplacement(ctx, path2, entryFile, bindings, halting) {
   if (check) {
     replacement.push(check);
   }
-  return t6.blockStatement(replacement);
+  return t9.blockStatement(replacement);
 }
-function replaceBlock(ctx, path2, directive, bindings) {
+function replaceBlockDirective(ctx, path2, directive, bindings) {
   const halting = transformBlockContent(path2, bindings.mutations);
-  const rootFile = createRootFile(
+  const entryFile = createEntryFile(
     ctx,
-    bindings,
-    t6.functionExpression(
-      void 0,
-      bindings.locals,
-      t6.blockStatement(path2.node.body),
-      halting.hasYield,
-      true
-    )
+    path2,
+    ctx.options.mode === "server" || directive.isomorphic ? createRootFile(
+      ctx,
+      bindings,
+      t9.functionExpression(
+        void 0,
+        bindings.locals,
+        t9.blockStatement(path2.node.body),
+        halting.hasYield,
+        true
+      )
+    ) : void 0,
+    directive.target
   );
-  const entryFile = createEntryFile(ctx, path2, rootFile, directive.target);
   path2.replaceWith(
-    getBlockReplacement(ctx, path2, entryFile, bindings, halting)
+    getBlockDirectiveReplacement(ctx, path2, entryFile, bindings, halting)
   );
 }
-function splitBlock(ctx, path2, directive) {
-  replaceBlock(
+function splitBlockDirective(ctx, path2, directive) {
+  replaceBlockDirective(
     ctx,
     path2,
     directive,
@@ -905,63 +920,154 @@ function splitBlock(ctx, path2, directive) {
     )
   );
 }
+
+// src/utils/directive-check.ts
+var t10 = __toESM(require("@babel/types"), 1);
+function getValidDirectiveFromString(ctx, string) {
+  for (let i = 0, len = ctx.options.definitions.length; i < len; i++) {
+    const current = ctx.options.definitions[i];
+    switch (current.type) {
+      case "block-directive":
+      case "function-directive": {
+        if (current.directive === string) {
+          return current;
+        }
+        break;
+      }
+    }
+  }
+  return void 0;
+}
+function getDefinitionFromDirectives(ctx, path2) {
+  for (let i = 0, len = path2.node.directives.length; i < len; i++) {
+    const statement = path2.node.directives[i].value.value;
+    const directive = getValidDirectiveFromString(ctx, statement);
+    if (directive) {
+      return directive;
+    }
+  }
+  return void 0;
+}
+function getDefinitionFromFauxDirectives(ctx, path2) {
+  for (let i = 0, len = path2.node.body.length; i < len; i++) {
+    const statement = path2.node.body[i];
+    if (t10.isExpressionStatement(statement) && t10.isStringLiteral(statement.expression)) {
+      const directive = getValidDirectiveFromString(
+        ctx,
+        statement.expression.value
+      );
+      if (directive) {
+        return directive;
+      }
+    } else {
+      break;
+    }
+  }
+  return void 0;
+}
+function getDirectiveDefinitionFromBlock(ctx, path2) {
+  const parent = path2.getFunctionParent();
+  if (parent && !parent.node.async) {
+    return void 0;
+  }
+  return getDefinitionFromDirectives(ctx, path2) || getDefinitionFromFauxDirectives(ctx, path2);
+}
+function cleanBlockForDirectives(path2, definition) {
+  const newDirectives = [];
+  for (let i = 0, len = path2.node.directives.length; i < len; i++) {
+    const current = path2.node.directives[i];
+    if (current.value.value !== definition.directive) {
+      newDirectives.push(current);
+    }
+  }
+  path2.node.directives = newDirectives;
+}
+function cleanBlockForFauxDirectives(path2, definition) {
+  const body = path2.get("body");
+  for (let i = 0, len = body.length; i < len; i++) {
+    const statement = body[i];
+    if (t10.isExpressionStatement(statement.node) && t10.isStringLiteral(statement.node.expression)) {
+      if (statement.node.expression.value === definition.directive) {
+        statement.remove();
+        return;
+      }
+    }
+  }
+}
+
+// src/transform-block-directive.ts
+function transformBlockDirective(ctx, path2) {
+  const definition = getDirectiveDefinitionFromBlock(ctx, path2);
+  if (!definition || definition.type !== "block-directive") {
+    return;
+  }
+  cleanBlockForDirectives(path2, definition);
+  cleanBlockForFauxDirectives(path2, definition);
+  splitBlockDirective(ctx, path2, definition);
+}
+
+// src/transform-call.ts
+var t12 = __toESM(require("@babel/types"), 1);
+
+// src/split-call.ts
+var t11 = __toESM(require("@babel/types"), 1);
+
+// src/utils/assert.ts
+function assert(cond, error) {
+  if (!cond) {
+    throw new Error(error);
+  }
+}
+
+// src/split-call.ts
 function transformFunctionContent(path2, mutations) {
   const target = path2.scope.getFunctionParent() || path2.scope.getProgramParent();
-  const applyMutations = mutations.length ? path2.scope.generateUidIdentifier("mutate") : void 0;
-  let hasReturn = false;
-  let hasYield = false;
+  const applyMutations = mutations.length ? generateUniqueName(path2, "mutate") : void 0;
   path2.traverse({
     ReturnStatement(child) {
       const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
       if (parent === target) {
-        hasReturn = true;
         const replacement = [RETURN_KEY];
         if (child.node.argument) {
           replacement.push(child.node.argument);
         } else {
-          replacement.push(t6.nullLiteral());
+          replacement.push(t11.nullLiteral());
         }
         if (applyMutations) {
-          replacement.push(t6.callExpression(applyMutations, []));
+          replacement.push(t11.callExpression(applyMutations, []));
         }
-        child.replaceWith(t6.returnStatement(t6.arrayExpression(replacement)));
+        child.replaceWith(t11.returnStatement(t11.arrayExpression(replacement)));
         child.skip();
       }
-    },
-    YieldExpression(child) {
-      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
-      if (parent === target) {
-        hasYield = true;
-      }
     }
   });
-  const error = path2.scope.generateUidIdentifier("error");
+  const error = generateUniqueName(path2, "error");
   const throwResult = [THROW_KEY, error];
   const haltResult = [NO_HALT_KEY];
   if (applyMutations) {
-    throwResult.push(t6.callExpression(applyMutations, []));
-    haltResult.push(t6.nullLiteral());
-    haltResult.push(t6.callExpression(applyMutations, []));
+    throwResult.push(t11.callExpression(applyMutations, []));
+    haltResult.push(t11.nullLiteral());
+    haltResult.push(t11.callExpression(applyMutations, []));
   }
   const statements = [
-    t6.tryStatement(
-      t6.blockStatement(path2.node.body),
-      t6.catchClause(
+    t11.tryStatement(
+      t11.blockStatement(path2.node.body),
+      t11.catchClause(
         error,
-        t6.blockStatement([t6.returnStatement(t6.arrayExpression(throwResult))])
+        t11.blockStatement([t11.returnStatement(t11.arrayExpression(throwResult))])
       )
     ),
-    t6.returnStatement(t6.arrayExpression(haltResult))
+    t11.returnStatement(t11.arrayExpression(haltResult))
   ];
   if (applyMutations) {
     statements.unshift(
-      t6.variableDeclaration("const", [
-        t6.variableDeclarator(
+      t11.variableDeclaration("const", [
+        t11.variableDeclarator(
           applyMutations,
-          t6.arrowFunctionExpression(
+          t11.arrowFunctionExpression(
             [],
-            t6.objectExpression(
-              mutations.map((item) => t6.objectProperty(item, item, false, true))
+            t11.objectExpression(
+              mutations.map((item) => t11.objectProperty(item, item, false, true))
             )
           )
         )
@@ -969,160 +1075,241 @@ function transformFunctionContent(path2, mutations) {
     );
   }
   path2.node.body = statements;
-  return {
-    hasReturn,
-    hasYield
-  };
 }
-function getFunctionReplacement(ctx, path2, entryFile, bindings, halting) {
-  const rest = path2.scope.generateUidIdentifier("rest");
-  const returnType = path2.scope.generateUidIdentifier("type");
-  const returnResult = path2.scope.generateUidIdentifier("result");
-  const returnMutations = path2.scope.generateUidIdentifier("mutations");
+function getFunctionReplacement(ctx, path2, entryFile, bindings) {
+  const rest = generateUniqueName(path2, "rest");
+  const returnType = generateUniqueName(path2, "type");
+  const returnResult = generateUniqueName(path2, "result");
+  const returnMutations = generateUniqueName(path2, "mutations");
+  const source = generateUniqueName(path2, "source");
   const replacement = [];
-  if (halting.hasYield) {
-    const funcID = path2.scope.generateUidIdentifier("fn");
+  if (path2.node.generator) {
+    const funcID = generateUniqueName(path2, "fn");
     replacement.push(
-      t6.variableDeclaration("const", [
-        t6.variableDeclarator(
+      t11.variableDeclaration("const", [
+        t11.variableDeclarator(
           funcID,
-          t6.callExpression(getImportIdentifier(ctx, path2, HIDDEN_GENERATOR), [
-            t6.memberExpression(
-              t6.awaitExpression(t6.importExpression(t6.stringLiteral(entryFile))),
-              t6.identifier("default")
-            ),
-            bindings.mutations.length ? t6.arrowFunctionExpression(
+          t11.callExpression(getImportIdentifier(ctx, path2, HIDDEN_GENERATOR), [
+            source,
+            bindings.mutations.length ? t11.arrowFunctionExpression(
               [returnMutations],
-              t6.assignmentExpression(
+              t11.assignmentExpression(
                 "=",
-                t6.objectPattern(
+                t11.objectPattern(
                   bindings.mutations.map(
-                    (item) => t6.objectProperty(item, item, false, true)
+                    (item) => t11.objectProperty(item, item, false, true)
                   )
                 ),
                 returnMutations
               )
-            ) : t6.nullLiteral()
+            ) : t11.nullLiteral()
           ])
         )
       ])
     );
-    const [reps, step] = getGeneratorReplacementForServerBlock(path2, funcID, [
-      t6.arrayExpression(bindings.locals),
-      t6.spreadElement(rest)
+    const [reps, step] = getGeneratorReplacementForBlock(path2, funcID, [
+      t11.arrayExpression(bindings.locals),
+      t11.spreadElement(rest)
     ]);
     for (let i = 0, len = reps.length; i < len; i++) {
       replacement.push(reps[i]);
     }
     replacement.push(
-      t6.variableDeclaration("const", [
-        t6.variableDeclarator(
-          t6.arrayPattern([returnType, returnResult]),
-          t6.memberExpression(step, t6.identifier("value"))
+      t11.variableDeclaration("const", [
+        t11.variableDeclarator(
+          t11.arrayPattern([returnType, returnResult]),
+          t11.memberExpression(step, t11.identifier("value"))
         )
       ])
     );
   } else {
     replacement.push(
-      t6.variableDeclaration("const", [
-        t6.variableDeclarator(
-          t6.arrayPattern([returnType, returnResult]),
-          t6.awaitExpression(
-            t6.callExpression(
-              t6.callExpression(getImportIdentifier(ctx, path2, HIDDEN_FUNC), [
-                t6.memberExpression(
-                  t6.awaitExpression(
-                    t6.importExpression(t6.stringLiteral(entryFile))
-                  ),
-                  t6.identifier("default")
-                ),
-                bindings.mutations.length ? t6.arrowFunctionExpression(
+      t11.variableDeclaration("const", [
+        t11.variableDeclarator(
+          t11.arrayPattern([returnType, returnResult]),
+          t11.awaitExpression(
+            t11.callExpression(
+              t11.callExpression(getImportIdentifier(ctx, path2, HIDDEN_FUNC), [
+                source,
+                bindings.mutations.length ? t11.arrowFunctionExpression(
                   [returnMutations],
-                  t6.assignmentExpression(
+                  t11.assignmentExpression(
                     "=",
-                    t6.objectPattern(
+                    t11.objectPattern(
                       bindings.mutations.map(
-                        (item) => t6.objectProperty(item, item, false, true)
+                        (item) => t11.objectProperty(item, item, false, true)
                       )
                     ),
                     returnMutations
                   )
-                ) : t6.nullLiteral()
+                ) : t11.nullLiteral()
               ]),
-              [t6.arrayExpression(bindings.locals), t6.spreadElement(rest)]
+              [t11.arrayExpression(bindings.locals), t11.spreadElement(rest)]
             )
           )
         )
       ])
     );
   }
-  replacement.push(t6.returnStatement(returnResult));
-  if (isPathValid(path2, t6.isFunctionExpression)) {
-    return t6.functionExpression(
-      path2.node.id,
-      [t6.restElement(rest)],
-      t6.blockStatement(replacement),
-      halting.hasYield,
-      true
-    );
+  replacement.push(t11.returnStatement(returnResult));
+  return t11.arrowFunctionExpression(
+    [],
+    t11.blockStatement([
+      t11.variableDeclaration("const", [
+        t11.variableDeclarator(
+          source,
+          t11.memberExpression(
+            t11.awaitExpression(t11.importExpression(t11.stringLiteral(entryFile))),
+            t11.identifier("default")
+          )
+        )
+      ]),
+      t11.returnStatement(
+        isPathValid(path2, t11.isFunctionExpression) ? t11.functionExpression(
+          path2.node.id,
+          [t11.restElement(rest)],
+          t11.blockStatement(replacement),
+          path2.node.generator,
+          true
+        ) : t11.arrowFunctionExpression(
+          [t11.restElement(rest)],
+          t11.blockStatement(replacement),
+          true
+        )
+      )
+    ]),
+    true
+  );
+}
+function replaceIsomorphicFunction(ctx, path2, func, bindings) {
+  const body = path2.get("body");
+  if (isPathValid(body, t11.isExpression)) {
+    body.replaceWith(t11.blockStatement([t11.returnStatement(body.node)]));
   }
-  return t6.arrowFunctionExpression(
-    [t6.restElement(rest)],
-    t6.blockStatement(replacement),
+  assert(isPathValid(body, t11.isBlockStatement), "invariant");
+  const entryFile = createEntryFile(
+    ctx,
+    path2,
+    createRootFile(
+      ctx,
+      bindings,
+      t11.isFunctionExpression(path2.node) ? t11.functionExpression(
+        path2.node.id,
+        [t11.arrayPattern(bindings.locals), ...path2.node.params],
+        path2.node.body,
+        path2.node.generator,
+        path2.node.async
+      ) : t11.arrowFunctionExpression(
+        [t11.arrayPattern(bindings.locals), ...path2.node.params],
+        path2.node.body,
+        path2.node.async
+      )
+    ),
+    func.target
+  );
+  const source = generateUniqueName(path2, "source");
+  const rest = generateUniqueName(path2, "rest");
+  return t11.arrowFunctionExpression(
+    [],
+    t11.blockStatement([
+      t11.variableDeclaration("const", [
+        t11.variableDeclarator(
+          source,
+          t11.memberExpression(
+            t11.awaitExpression(t11.importExpression(t11.stringLiteral(entryFile))),
+            t11.identifier("default")
+          )
+        )
+      ]),
+      t11.returnStatement(
+        t11.arrowFunctionExpression(
+          [t11.restElement(rest)],
+          t11.callExpression(source, [
+            t11.arrayExpression(bindings.locals),
+            t11.spreadElement(rest)
+          ]),
+          path2.node.async
+        )
+      )
+    ]),
     true
   );
 }
-function replaceFunction(ctx, path2, func, bindings) {
+function replaceFunctionFromCall(ctx, path2, func, bindings) {
   const body = path2.get("body");
-  if (isPathValid(body, t6.isExpression)) {
-    body.replaceWith(t6.blockStatement([t6.returnStatement(body.node)]));
+  if (isPathValid(body, t11.isExpression)) {
+    body.replaceWith(t11.blockStatement([t11.returnStatement(body.node)]));
   }
-  assert(isPathValid(body, t6.isBlockStatement), "invariant");
-  const halting = transformFunctionContent(body, bindings.mutations);
-  const rootFile = createRootFile(
+  assert(isPathValid(body, t11.isBlockStatement), "invariant");
+  transformFunctionContent(body, bindings.mutations);
+  const entryFile = createEntryFile(
     ctx,
-    bindings,
-    t6.isFunctionExpression(path2.node) ? t6.functionExpression(
-      path2.node.id,
-      [t6.arrayPattern(bindings.locals), ...path2.node.params],
-      path2.node.body,
-      path2.node.async,
-      path2.node.generator
-    ) : t6.arrowFunctionExpression(
-      [t6.arrayPattern(bindings.locals), ...path2.node.params],
-      path2.node.body,
-      path2.node.async
-    )
+    path2,
+    ctx.options.mode === "server" || func.isomorphic ? createRootFile(
+      ctx,
+      bindings,
+      t11.isFunctionExpression(path2.node) ? t11.functionExpression(
+        path2.node.id,
+        [t11.arrayPattern(bindings.locals), ...path2.node.params],
+        path2.node.body,
+        path2.node.generator,
+        path2.node.async
+      ) : t11.arrowFunctionExpression(
+        [t11.arrayPattern(bindings.locals), ...path2.node.params],
+        path2.node.body,
+        path2.node.async
+      )
+    ) : void 0,
+    func.target
   );
-  const entryFile = createEntryFile(ctx, path2, rootFile, func.target);
-  return getFunctionReplacement(ctx, path2, entryFile, bindings, halting);
+  return getFunctionReplacement(ctx, path2, entryFile, bindings);
 }
-function splitFunction(ctx, path2, func) {
-  return replaceFunction(
+function splitFunctionFromCall(ctx, path2, func) {
+  const bindings = extractBindings(
     ctx,
     path2,
-    func,
-    extractBindings(ctx, path2, getForeignBindings(path2, "function"), func.pure)
+    getForeignBindings(path2, "function"),
+    func.pure
   );
+  if (func.isomorphic) {
+    return replaceIsomorphicFunction(ctx, path2, func, bindings);
+  }
+  return replaceFunctionFromCall(ctx, path2, func, bindings);
 }
-function replaceExpression(ctx, path2, func, bindings) {
-  const rootFile = createRootFile(ctx, bindings, path2.node);
-  const entryFile = createEntryFile(ctx, path2, rootFile, func.target);
-  const rest = path2.scope.generateUidIdentifier("rest");
-  return t6.arrowFunctionExpression(
-    [t6.restElement(rest)],
-    t6.callExpression(
-      t6.memberExpression(
-        t6.awaitExpression(t6.importExpression(t6.stringLiteral(entryFile))),
-        t6.identifier("default")
-      ),
-      [t6.spreadElement(rest)]
-    ),
+function replaceExpressionFromCall(ctx, path2, func, bindings) {
+  const entryFile = createEntryFile(
+    ctx,
+    path2,
+    ctx.options.mode === "server" || func.isomorphic ? createRootFile(ctx, bindings, path2.node) : void 0,
+    func.target
+  );
+  const rest = generateUniqueName(path2, "rest");
+  const source = generateUniqueName(path2, "source");
+  return t11.arrowFunctionExpression(
+    [],
+    t11.blockStatement([
+      t11.variableDeclaration("const", [
+        t11.variableDeclarator(
+          source,
+          t11.memberExpression(
+            t11.awaitExpression(t11.importExpression(t11.stringLiteral(entryFile))),
+            t11.identifier("default")
+          )
+        )
+      ]),
+      t11.returnStatement(
+        t11.arrowFunctionExpression(
+          [t11.restElement(rest)],
+          t11.callExpression(source, [t11.spreadElement(rest)]),
+          true
+        )
+      )
+    ]),
     true
   );
 }
-function splitExpression(ctx, path2, func) {
-  return replaceExpression(
+function splitExpressionFromCall(ctx, path2, func) {
+  return replaceExpressionFromCall(
     ctx,
     path2,
     func,
@@ -1135,84 +1322,7 @@ function splitExpression(ctx, path2, func) {
   );
 }
 
-// src/transform-block.ts
-function getValidDirectiveFromString(ctx, string) {
-  for (let i = 0, len = ctx.options.directives.length; i < len; i++) {
-    const current = ctx.options.directives[i];
-    if (current.value === string) {
-      return current;
-    }
-  }
-  return void 0;
-}
-function getDefinitionFromDirectives(ctx, path2) {
-  for (let i = 0, len = path2.node.directives.length; i < len; i++) {
-    const statement = path2.node.directives[i].value.value;
-    const directive = getValidDirectiveFromString(ctx, statement);
-    if (directive) {
-      return directive;
-    }
-  }
-  return void 0;
-}
-function getDefinitionFromFauxDirectives(ctx, path2) {
-  for (let i = 0, len = path2.node.body.length; i < len; i++) {
-    const statement = path2.node.body[i];
-    if (statement.type === "ExpressionStatement" && statement.expression.type === "StringLiteral") {
-      const directive = getValidDirectiveFromString(
-        ctx,
-        statement.expression.value
-      );
-      if (directive) {
-        return directive;
-      }
-    } else {
-      break;
-    }
-  }
-  return void 0;
-}
-function getDirectiveDefinitionFromBlock(ctx, path2) {
-  const parent = path2.getFunctionParent();
-  if (parent && !parent.node.async) {
-    return void 0;
-  }
-  return getDefinitionFromDirectives(ctx, path2) || getDefinitionFromFauxDirectives(ctx, path2);
-}
-function cleanBlockForDirectives(path2, definition) {
-  const newDirectives = [];
-  for (let i = 0, len = path2.node.directives.length; i < len; i++) {
-    const current = path2.node.directives[i];
-    if (current.value.value !== definition.value) {
-      newDirectives.push(current);
-    }
-  }
-  path2.node.directives = newDirectives;
-}
-function cleanBlockForFauxDirectives(path2, definition) {
-  const body = path2.get("body");
-  for (let i = 0, len = body.length; i < len; i++) {
-    const statement = body[i];
-    if (statement.node.type === "ExpressionStatement" && statement.node.expression.type === "StringLiteral") {
-      if (statement.node.expression.value === definition.value) {
-        statement.remove();
-        return;
-      }
-    }
-  }
-}
-function transformBlock(ctx, path2) {
-  const definition = getDirectiveDefinitionFromBlock(ctx, path2);
-  if (!definition) {
-    return;
-  }
-  cleanBlockForDirectives(path2, definition);
-  cleanBlockForFauxDirectives(path2, definition);
-  splitBlock(ctx, path2, definition);
-}
-
 // src/transform-call.ts
-var t7 = __toESM(require("@babel/types"), 1);
 function getFunctionDefinitionFromPropName(definitions, propName) {
   for (let i = 0, len = definitions.length; i < len; i++) {
     const def = definitions[i];
@@ -1227,7 +1337,7 @@ function getFunctionDefinitionFromPropName(definitions, propName) {
 }
 function getFunctionDefinitionFromCallee(ctx, path2) {
   const callee = path2.node.callee;
-  const id = unwrapNode(callee, t7.isIdentifier);
+  const id = unwrapNode(callee, t12.isIdentifier);
   if (id) {
     const binding = path2.scope.getBindingIdentifier(id.name);
     if (binding) {
@@ -1235,9 +1345,9 @@ function getFunctionDefinitionFromCallee(ctx, path2) {
     }
     return void 0;
   }
-  const memberExpr = unwrapNode(callee, t7.isMemberExpression);
-  if (memberExpr && !memberExpr.computed && t7.isIdentifier(memberExpr.property)) {
-    const object = unwrapNode(memberExpr.object, t7.isIdentifier);
+  const memberExpr = unwrapNode(callee, t12.isMemberExpression);
+  if (memberExpr && !memberExpr.computed && t12.isIdentifier(memberExpr.property)) {
+    const object = unwrapNode(memberExpr.object, t12.isIdentifier);
     if (object) {
       const binding = path2.scope.getBindingIdentifier(object.name);
       if (binding) {
@@ -1254,7 +1364,7 @@ function getFunctionDefinitionFromCallee(ctx, path2) {
   return void 0;
 }
 function isValidFunction(node) {
-  return t7.isArrowFunctionExpression(node) || t7.isFunctionExpression(node);
+  return t12.isArrowFunctionExpression(node) || t12.isFunctionExpression(node);
 }
 function isSkippableFunction(node) {
   if (node.leadingComments) {
@@ -1273,23 +1383,355 @@ function transformCall(ctx, path2) {
   }
   const args = path2.get("arguments");
   const expr = args[0];
-  if (isPathValid(expr, t7.isExpression)) {
-    if (isSkippableFunction(expr.node)) {
+  if (isPathValid(expr, t12.isExpression) && !isSkippableFunction(expr.node)) {
+    const replacement = isPathValid(expr, isValidFunction) ? splitFunctionFromCall(ctx, expr, definition) : splitExpressionFromCall(ctx, expr, definition);
+    path2.replaceWith(
+      t12.callExpression(getImportIdentifier(ctx, path2, definition.handle), [
+        t12.addComment(replacement, "leading", "@dismantle skip")
+      ])
+    );
+  }
+}
+
+// src/transform-function-directive.ts
+var t14 = __toESM(require("@babel/types"), 1);
+
+// src/split-function-directive.ts
+var t13 = __toESM(require("@babel/types"), 1);
+function transformFunctionContent2(path2, mutations) {
+  const target = path2.scope.getFunctionParent() || path2.scope.getProgramParent();
+  const applyMutations = mutations.length ? generateUniqueName(path2, "mutate") : void 0;
+  path2.traverse({
+    ReturnStatement(child) {
+      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
+      if (parent === target) {
+        const replacement = [RETURN_KEY];
+        if (child.node.argument) {
+          replacement.push(child.node.argument);
+        } else {
+          replacement.push(t13.nullLiteral());
+        }
+        if (applyMutations) {
+          replacement.push(t13.callExpression(applyMutations, []));
+        }
+        child.replaceWith(t13.returnStatement(t13.arrayExpression(replacement)));
+        child.skip();
+      }
+    }
+  });
+  const error = generateUniqueName(path2, "error");
+  const throwResult = [THROW_KEY, error];
+  const haltResult = [NO_HALT_KEY];
+  if (applyMutations) {
+    throwResult.push(t13.callExpression(applyMutations, []));
+    haltResult.push(t13.nullLiteral());
+    haltResult.push(t13.callExpression(applyMutations, []));
+  }
+  const statements = [
+    t13.tryStatement(
+      t13.blockStatement(path2.node.body),
+      t13.catchClause(
+        error,
+        t13.blockStatement([t13.returnStatement(t13.arrayExpression(throwResult))])
+      )
+    ),
+    t13.returnStatement(t13.arrayExpression(haltResult))
+  ];
+  if (applyMutations) {
+    statements.unshift(
+      t13.variableDeclaration("const", [
+        t13.variableDeclarator(
+          applyMutations,
+          t13.arrowFunctionExpression(
+            [],
+            t13.objectExpression(
+              mutations.map((item) => t13.objectProperty(item, item, false, true))
+            )
+          )
+        )
+      ])
+    );
+  }
+  path2.node.body = statements;
+}
+function getFunctionReplacement2(ctx, path2, entryFile, bindings) {
+  const rest = generateUniqueName(path2, "rest");
+  const returnType = generateUniqueName(path2, "type");
+  const returnResult = generateUniqueName(path2, "result");
+  const returnMutations = generateUniqueName(path2, "mutations");
+  const source = generateUniqueName(path2, "source");
+  const replacement = [];
+  if (path2.node.generator) {
+    const funcID = generateUniqueName(path2, "fn");
+    replacement.push(
+      t13.variableDeclaration("const", [
+        t13.variableDeclarator(
+          funcID,
+          t13.callExpression(getImportIdentifier(ctx, path2, HIDDEN_GENERATOR), [
+            source,
+            bindings.mutations.length ? t13.arrowFunctionExpression(
+              [returnMutations],
+              t13.assignmentExpression(
+                "=",
+                t13.objectPattern(
+                  bindings.mutations.map(
+                    (item) => t13.objectProperty(item, item, false, true)
+                  )
+                ),
+                returnMutations
+              )
+            ) : t13.nullLiteral()
+          ])
+        )
+      ])
+    );
+    const [reps, step] = getGeneratorReplacementForBlock(path2, funcID, [
+      t13.arrayExpression(bindings.locals),
+      t13.spreadElement(rest)
+    ]);
+    for (let i = 0, len = reps.length; i < len; i++) {
+      replacement.push(reps[i]);
+    }
+    replacement.push(
+      t13.variableDeclaration("const", [
+        t13.variableDeclarator(
+          t13.arrayPattern([returnType, returnResult]),
+          t13.memberExpression(step, t13.identifier("value"))
+        )
+      ])
+    );
+  } else {
+    replacement.push(
+      t13.variableDeclaration("const", [
+        t13.variableDeclarator(
+          t13.arrayPattern([returnType, returnResult]),
+          t13.awaitExpression(
+            t13.callExpression(
+              t13.callExpression(getImportIdentifier(ctx, path2, HIDDEN_FUNC), [
+                source,
+                bindings.mutations.length ? t13.arrowFunctionExpression(
+                  [returnMutations],
+                  t13.assignmentExpression(
+                    "=",
+                    t13.objectPattern(
+                      bindings.mutations.map(
+                        (item) => t13.objectProperty(item, item, false, true)
+                      )
+                    ),
+                    returnMutations
+                  )
+                ) : t13.nullLiteral()
+              ]),
+              [t13.arrayExpression(bindings.locals), t13.spreadElement(rest)]
+            )
+          )
+        )
+      ])
+    );
+  }
+  replacement.push(t13.returnStatement(returnResult));
+  return t13.arrowFunctionExpression(
+    [],
+    t13.blockStatement([
+      t13.variableDeclaration("const", [
+        t13.variableDeclarator(
+          source,
+          t13.memberExpression(
+            t13.awaitExpression(t13.importExpression(t13.stringLiteral(entryFile))),
+            t13.identifier("default")
+          )
+        )
+      ]),
+      t13.returnStatement(
+        isPathValid(path2, t13.isFunctionExpression) ? t13.functionExpression(
+          path2.node.id,
+          [t13.restElement(rest)],
+          t13.blockStatement(replacement),
+          path2.node.generator,
+          true
+        ) : t13.arrowFunctionExpression(
+          [t13.restElement(rest)],
+          t13.blockStatement(replacement),
+          true
+        )
+      )
+    ]),
+    true
+  );
+}
+function replaceIsomorphicFunction2(ctx, path2, directive, bindings) {
+  const body = path2.get("body");
+  if (isPathValid(body, t13.isExpression)) {
+    body.replaceWith(t13.blockStatement([t13.returnStatement(body.node)]));
+  }
+  assert(isPathValid(body, t13.isBlockStatement), "invariant");
+  const entryFile = createEntryFile(
+    ctx,
+    path2,
+    createRootFile(
+      ctx,
+      bindings,
+      t13.isFunctionExpression(path2.node) ? t13.functionExpression(
+        path2.node.id,
+        [t13.arrayPattern(bindings.locals), ...path2.node.params],
+        path2.node.body,
+        path2.node.generator,
+        path2.node.async
+      ) : t13.arrowFunctionExpression(
+        [t13.arrayPattern(bindings.locals), ...path2.node.params],
+        path2.node.body,
+        path2.node.async
+      )
+    ),
+    directive.target
+  );
+  const source = generateUniqueName(path2, "source");
+  const rest = generateUniqueName(path2, "rest");
+  return t13.arrowFunctionExpression(
+    [],
+    t13.blockStatement([
+      t13.variableDeclaration("const", [
+        t13.variableDeclarator(
+          source,
+          t13.memberExpression(
+            t13.awaitExpression(t13.importExpression(t13.stringLiteral(entryFile))),
+            t13.identifier("default")
+          )
+        )
+      ]),
+      t13.returnStatement(
+        t13.arrowFunctionExpression(
+          [t13.restElement(rest)],
+          t13.callExpression(source, [
+            t13.arrayExpression(bindings.locals),
+            t13.spreadElement(rest)
+          ]),
+          path2.node.async
+        )
+      )
+    ]),
+    true
+  );
+}
+function replaceFunctionDirective(ctx, path2, directive, bindings) {
+  const body = path2.get("body");
+  if (isPathValid(body, t13.isExpression)) {
+    body.replaceWith(t13.blockStatement([t13.returnStatement(body.node)]));
+  }
+  assert(isPathValid(body, t13.isBlockStatement), "invariant");
+  transformFunctionContent2(body, bindings.mutations);
+  const entryFile = createEntryFile(
+    ctx,
+    path2,
+    ctx.options.mode === "server" || directive.isomorphic ? createRootFile(
+      ctx,
+      bindings,
+      t13.isFunctionExpression(path2.node) ? t13.functionExpression(
+        path2.node.id,
+        [t13.arrayPattern(bindings.locals), ...path2.node.params],
+        path2.node.body,
+        path2.node.generator,
+        path2.node.async
+      ) : t13.arrowFunctionExpression(
+        [t13.arrayPattern(bindings.locals), ...path2.node.params],
+        path2.node.body,
+        path2.node.async
+      )
+    ) : void 0,
+    directive.target
+  );
+  return getFunctionReplacement2(ctx, path2, entryFile, bindings);
+}
+function splitFunctionDirective(ctx, path2, directive) {
+  const bindings = extractBindings(
+    ctx,
+    path2,
+    getForeignBindings(path2, "function"),
+    directive.pure
+  );
+  if (directive.isomorphic) {
+    return replaceIsomorphicFunction2(ctx, path2, directive, bindings);
+  }
+  return replaceFunctionDirective(ctx, path2, directive, bindings);
+}
+
+// src/transform-function-directive.ts
+function transformFunctionDirective(ctx, path2) {
+  const body = path2.get("body");
+  if (isPathValid(body, t14.isBlockStatement)) {
+    const definition = getDirectiveDefinitionFromBlock(ctx, body);
+    if (!definition || definition.type !== "function-directive") {
       return;
     }
-    const replacement = isPathValid(expr, isValidFunction) ? splitFunction(ctx, expr, definition) : splitExpression(ctx, expr, definition);
-    if (definition.preserve) {
-      expr.replaceWith(t7.addComment(replacement, "leading", "@dismantle skip"));
-    } else {
-      path2.replaceWith(replacement);
+    cleanBlockForDirectives(body, definition);
+    cleanBlockForFauxDirectives(body, definition);
+    const replacement = splitFunctionDirective(ctx, path2, definition);
+    path2.replaceWith(
+      t14.callExpression(getImportIdentifier(ctx, path2, definition.handle), [
+        replacement
+      ])
+    );
+  }
+}
+
+// src/utils/bubble-function-declaration.ts
+var t15 = __toESM(require("@babel/types"), 1);
+
+// src/utils/is-statement-top-level.ts
+function isStatementTopLevel(path2) {
+  let blockParent = path2.scope.getBlockParent();
+  const programParent = path2.scope.getProgramParent();
+  if (blockParent.path === path2) {
+    blockParent = blockParent.parent;
+  }
+  return programParent === blockParent;
+}
+
+// src/utils/bubble-function-declaration.ts
+function bubbleFunctionDeclaration(ctx, program2, path2) {
+  if (isStatementTopLevel(path2)) {
+    const decl = path2.node;
+    if (decl.id) {
+      const definition = getDirectiveDefinitionFromBlock(ctx, path2.get("body"));
+      if (!definition || definition.type !== "function-directive") {
+        return;
+      }
+      const [tmp] = program2.unshiftContainer(
+        "body",
+        t15.variableDeclaration("const", [
+          t15.variableDeclarator(
+            decl.id,
+            t15.functionExpression(
+              decl.id,
+              decl.params,
+              decl.body,
+              decl.generator,
+              decl.async
+            )
+          )
+        ])
+      );
+      program2.scope.registerDeclaration(tmp);
+      tmp.skip();
+      if (path2.parentPath.isExportNamedDeclaration()) {
+        path2.parentPath.replaceWith(
+          t15.exportNamedDeclaration(void 0, [
+            t15.exportSpecifier(decl.id, decl.id)
+          ])
+        );
+      } else if (path2.parentPath.isExportDefaultDeclaration()) {
+        path2.replaceWith(decl.id);
+      } else {
+        path2.remove();
+      }
     }
   }
 }
 
 // src/utils/register-import-specifiers.ts
-var t8 = __toESM(require("@babel/types"), 1);
+var t16 = __toESM(require("@babel/types"), 1);
 function registerImportSpecifier(ctx, node, definition) {
-  if (t8.isImportSpecifier(node)) {
+  if (t16.isImportSpecifier(node)) {
     if (node.importKind === "type" || node.importKind === "typeof") {
       return;
     }
@@ -1298,10 +1740,10 @@ function registerImportSpecifier(ctx, node, definition) {
       ctx.registrations.identifiers.set(node.local, definition);
     }
   }
-  if (t8.isImportDefaultSpecifier(node) && definition.source.kind === "default") {
+  if (t16.isImportDefaultSpecifier(node) && definition.source.kind === "default") {
     ctx.registrations.identifiers.set(node.local, definition);
   }
-  if (t8.isImportNamespaceSpecifier(node)) {
+  if (t16.isImportNamespaceSpecifier(node)) {
     let current = ctx.registrations.namespaces.get(node.local);
     if (!current) {
       current = [];
@@ -1317,7 +1759,7 @@ function registerImportDeclarationByDefinition(ctx, path2, definition) {
   }
 }
 function registerImportSpecifiers(ctx, programPath) {
-  const len = ctx.options.functions.length;
+  const len = ctx.options.definitions.length;
   if (!len) {
     return;
   }
@@ -1327,8 +1769,8 @@ function registerImportSpecifiers(ctx, programPath) {
         return;
       }
       for (let i = 0; i < len; i++) {
-        const func = ctx.options.functions[i];
-        if (func.source.source === path2.node.source.value) {
+        const func = ctx.options.definitions[i];
+        if (func.type === "function-call" && func.source.source === path2.node.source.value) {
           registerImportDeclarationByDefinition(ctx, path2, func);
         }
       }
@@ -1341,11 +1783,22 @@ function plugin() {
   return {
     name: "dismantle",
     visitor: {
-      Program(path2, ctx) {
-        registerImportSpecifiers(ctx.opts, path2);
+      Program(programPath, ctx) {
+        registerImportSpecifiers(ctx.opts, programPath);
+        programPath.traverse({
+          FunctionDeclaration(path2) {
+            bubbleFunctionDeclaration(ctx.opts, programPath, path2);
+          }
+        });
+      },
+      ArrowFunctionExpression(path2, ctx) {
+        transformFunctionDirective(ctx.opts, path2);
+      },
+      FunctionExpression(path2, ctx) {
+        transformFunctionDirective(ctx.opts, path2);
       },
       BlockStatement(path2, ctx) {
-        transformBlock(ctx.opts, path2);
+        transformBlockDirective(ctx.opts, path2);
       },
       CallExpression(path2, ctx) {
         transformCall(ctx.opts, path2);
@@ -1469,7 +1922,19 @@ async function compile(id, code, options) {
       namespaces: /* @__PURE__ */ new Map()
     }
   };
-  const plugins = ["jsx"];
+  const plugins = [
+    "jsx",
+    // import { example } from 'example' with { example: true };
+    "importAttributes",
+    // () => throw example
+    "throwExpressions",
+    // You know what this is
+    "decorators",
+    // const { #example: example } = this;
+    "destructuringPrivate",
+    // using example = myExample()
+    "explicitResourceManagement"
+  ];
   if (/\.[mc]?tsx?$/i.test(id)) {
     plugins.push("typescript");
   }