dismantle 0.4.3 → 0.5.0

package/dist/cjs/development/index.cjs

@@ -37,9 +37,9 @@ var babel = __toESM(require("@babel/core"), 1);
 var import_node_path = __toESM(require("node:path"), 1);
 
 // src/split-block-directive.ts
-var t9 = __toESM(require("@babel/types"), 1);
+var t7 = __toESM(require("@babel/types"), 1);
 
-// src/hidden-imports.ts
+// src/constants.ts
 var HIDDEN_FUNC = {
   kind: "named",
   source: "dismantle/runtime",
@@ -50,9 +50,23 @@ var HIDDEN_GENERATOR = {
   source: "dismantle/runtime",
   name: "$$gen"
 };
+var HIDDEN_CONTEXT = {
+  kind: "named",
+  source: "dismantle/runtime",
+  name: "$$context"
+};
+var DISMANTLE_CONTEXT = "dismantle__context";
+var DISMANTLE_GEN = "dismantle__gen";
+var DISMANTLE_FUNC = "dismantle__func";
 
 // src/split.ts
-var t7 = __toESM(require("@babel/types"), 1);
+var t5 = __toESM(require("@babel/types"), 1);
+
+// src/patch-v8-identifier.ts
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+
+// src/utils/get-import-identifier.ts
+var t2 = __toESM(require("@babel/types"), 1);
 
 // src/utils/generate-unique-name.ts
 var t = __toESM(require("@babel/types"), 1);
@@ -69,6 +83,69 @@ function generateUniqueName(path2, name) {
   return t.identifier(uid);
 }
 
+// src/utils/get-import-identifier.ts
+function getImportIdentifier(imports, path2, registration) {
+  const name = registration.kind === "named" ? registration.name : "default";
+  const target = `${registration.source}[${name}]`;
+  const current = imports.get(target);
+  if (current) {
+    return current;
+  }
+  const programParent = path2.scope.getProgramParent();
+  const uid = generateUniqueName(programParent.path, name);
+  programParent.registerDeclaration(
+    programParent.path.unshiftContainer(
+      "body",
+      t2.importDeclaration(
+        [
+          registration.kind === "named" ? t2.importSpecifier(uid, t2.identifier(registration.name)) : t2.importDefaultSpecifier(uid)
+        ],
+        t2.stringLiteral(registration.source)
+      )
+    )[0]
+  );
+  imports.set(target, uid);
+  return uid;
+}
+
+// src/patch-v8-identifier.ts
+function getV8Replacement(ctx, path2) {
+  switch (path2.node.name) {
+    case DISMANTLE_CONTEXT:
+      return getImportIdentifier(ctx.map, path2, {
+        ...HIDDEN_CONTEXT,
+        source: ctx.runtime
+      });
+    case DISMANTLE_FUNC:
+      return getImportIdentifier(ctx.map, path2, {
+        ...HIDDEN_FUNC,
+        source: ctx.runtime
+      });
+    case DISMANTLE_GEN:
+      return getImportIdentifier(ctx.map, path2, {
+        ...HIDDEN_GENERATOR,
+        source: ctx.runtime
+      });
+    default:
+      return void 0;
+  }
+}
+var V8_PATCH = {
+  V8IntrinsicIdentifier(path2, ctx) {
+    const result = getV8Replacement(ctx, path2);
+    if (result) {
+      path2.replaceWith(result);
+    }
+  }
+};
+var traverse = typeof import_traverse.default !== "function" ? import_traverse.default.default : import_traverse.default;
+function patchV8Identifier(ctx, node) {
+  traverse(node, V8_PATCH, void 0, {
+    map: /* @__PURE__ */ new Map(),
+    runtime: ctx.options.runtime
+  });
+}
+
 // src/utils/generator-shim.ts
 var import_generator = __toESM(require("@babel/generator"), 1);
 var generator = typeof import_generator.default !== "function" ? import_generator.default.default : import_generator.default;
@@ -122,99 +199,13 @@ function getDescriptiveName(path2, defaultName) {
   return defaultName;
 }
 
-// src/utils/get-foreign-bindings.ts
-var t2 = __toESM(require("@babel/types"), 1);
-function isForeignBinding(source, current, name, mode) {
-  if (current.scope.hasGlobal(name)) {
-    return false;
-  }
-  if (source === current) {
-    return true;
-  }
-  if (current.scope.hasOwnBinding(name)) {
-    if (mode === "block") {
-      const binding = current.scope.getBinding(name);
-      return !!binding && binding.kind === "param";
-    }
-    return false;
-  }
-  if (current.parentPath) {
-    return isForeignBinding(source, current.parentPath, name, mode);
-  }
-  return true;
-}
-function isInTypescript(path2) {
-  let parent = path2.parentPath;
-  while (parent) {
-    if (t2.isTypeScript(parent.node) && !t2.isExpression(parent.node)) {
-      return true;
-    }
-    parent = parent.parentPath;
-  }
-  return false;
-}
-function getForeignBindings(path2, mode) {
-  const identifiers = /* @__PURE__ */ new Set();
-  path2.traverse({
-    ReferencedIdentifier(p) {
-      if (!isInTypescript(p) && (mode === "expression" ? !path2.scope.hasGlobal(p.node.name) : isForeignBinding(path2, p, p.node.name, mode))) {
-        identifiers.add(p.node.name);
-      }
-    }
-  });
-  return identifiers;
-}
-
-// src/utils/get-identifiers-from-lval.ts
-var t3 = __toESM(require("@babel/types"), 1);
-function getIdentifiersFromArrayPattern(node) {
-  const ids = [];
-  for (let i = 0, len = node.elements.length; i < len; i++) {
-    const el = node.elements[i];
-    if (el) {
-      ids.push(...getIdentifiersFromLVal(el));
-    }
-  }
-  return ids;
-}
-function getIdentifiersFromObjectPattern(node) {
-  const ids = [];
-  for (let i = 0, len = node.properties.length; i < len; i++) {
-    const el = node.properties[i];
-    if (el) {
-      if (el.type === "RestElement") {
-        ids.push(...getIdentifiersFromLVal(el));
-      } else if (t3.isLVal(el.value)) {
-        ids.push(...getIdentifiersFromLVal(el.value));
-      }
-    }
-  }
-  return ids;
-}
-function getIdentifiersFromLVal(node) {
-  switch (node.type) {
-    case "Identifier":
-      return [node.name];
-    case "ArrayPattern":
-      return getIdentifiersFromArrayPattern(node);
-    case "AssignmentPattern":
-      return getIdentifiersFromLVal(node.left);
-    case "ObjectPattern":
-      return getIdentifiersFromObjectPattern(node);
-    case "RestElement":
-      return getIdentifiersFromLVal(node.argument);
-    default:
-      return [];
-  }
-}
-
 // src/utils/get-module-definition.ts
-var t5 = __toESM(require("@babel/types"), 1);
+var t4 = __toESM(require("@babel/types"), 1);
 
 // src/utils/get-import-specifier-name.ts
-var t4 = __toESM(require("@babel/types"), 1);
+var t3 = __toESM(require("@babel/types"), 1);
 function getImportSpecifierName(node) {
-  if (t4.isIdentifier(node.imported)) {
+  if (t3.isIdentifier(node.imported)) {
     return node.imported.name;
   }
   return node.imported.value;
@@ -222,7 +213,8 @@ function getImportSpecifierName(node) {
 
 // src/utils/unwrap.ts
 function isPathValid(path2, key) {
-  return key(path2.node);
+  const node = path2.node;
+  return node ? key(node) : false;
 }
 function isNestedExpression(node) {
   switch (node.type) {
@@ -259,7 +251,7 @@ function unwrapPath(path2, key) {
 
 // src/utils/get-module-definition.ts
 function getModuleDefinition(path2) {
-  if (!(isPathValid(path2, t5.isImportSpecifier) || isPathValid(path2, t5.isImportDefaultSpecifier) || isPathValid(path2, t5.isImportNamespaceSpecifier))) {
+  if (!(isPathValid(path2, t4.isImportSpecifier) || isPathValid(path2, t4.isImportDefaultSpecifier) || isPathValid(path2, t4.isImportNamespaceSpecifier))) {
     return void 0;
   }
   const parent = path2.getStatementParent();
@@ -297,38 +289,24 @@ function getModuleDefinition(path2) {
   }
 }
 
-// src/utils/get-root-statement-path.ts
-var t6 = __toESM(require("@babel/types"), 1);
-function getRootStatementPath(path2) {
-  let current = path2.parentPath;
-  while (current) {
-    const next = current.parentPath;
-    if (next && t6.isProgram(next.node)) {
-      return current;
-    }
-    current = next;
-  }
-  return path2;
-}
-
 // src/split.ts
 function moduleDefinitionToImportSpecifier(definition) {
   switch (definition.kind) {
     case "default":
-      return t7.importDefaultSpecifier(t7.identifier(definition.local));
+      return t5.importDefaultSpecifier(t5.identifier(definition.local));
     case "named":
-      return t7.importSpecifier(
-        t7.identifier(definition.local),
-        definition.imported ? t7.identifier(definition.imported) : t7.identifier(definition.local)
+      return t5.importSpecifier(
+        t5.identifier(definition.local),
+        definition.imported ? t5.identifier(definition.imported) : t5.identifier(definition.local)
       );
     case "namespace":
-      return t7.importNamespaceSpecifier(t7.identifier(definition.local));
+      return t5.importNamespaceSpecifier(t5.identifier(definition.local));
   }
 }
 function moduleDefinitionToImportDeclaration(definition) {
-  return t7.importDeclaration(
+  return t5.importDeclaration(
     [moduleDefinitionToImportSpecifier(definition)],
-    t7.stringLiteral(definition.source)
+    t5.stringLiteral(definition.source)
   );
 }
 function moduleDefinitionsToImportDeclarations(definitions) {
@@ -338,88 +316,178 @@ function moduleDefinitionsToImportDeclarations(definitions) {
   }
   return declarations;
 }
-function isMutation(kind) {
-  switch (kind) {
-    case "let":
-    case "var":
-    case "param":
-      return true;
+function addLocalDependency(dependencies, target) {
+  if (target.constant) {
+    if (!dependencies.locals.includes(target)) {
+      dependencies.locals.push(target);
+    }
+  } else if (!dependencies.mutations.includes(target)) {
+    dependencies.mutations.push(target);
+  }
+}
+function extractDependenciesFromVariableDeclarator(dependencies, target, isPure) {
+  if (!isPathValid(target.path, t5.isVariableDeclarator)) {
+    return;
+  }
+  const init = unwrapPath(target.path.get("init"), t5.isExpression);
+  if (init) {
+    if (isPathValid(init, t5.isArrowFunctionExpression) || isPathValid(init, t5.isFunctionExpression)) {
+      return;
+    }
+  }
+  if (!isPure) {
+    addLocalDependency(dependencies, target);
+  }
+}
+function extractDependency(dependencies, target, isPure) {
+  switch (target.kind) {
+    // For module imports, we just push to them
+    // to the module bindings
+    case "module": {
+      const definition = getModuleDefinition(target.path);
+      if (definition) {
+        dependencies.modules.push(definition);
+      }
+      break;
+    }
+    // For params, we push them as mutable locals
+    case "param": {
+      if (!isPure) {
+        addLocalDependency(dependencies, target);
+      }
+      break;
+    }
     case "const":
+    case "let":
+    case "var": {
+      extractDependenciesFromVariableDeclarator(dependencies, target, isPure);
+      break;
+    }
     case "hoisted":
+      break;
     case "local":
-    case "module":
     case "unknown":
-      return false;
+      break;
   }
 }
-function registerModuleLevelBinding(ctx, modules, binding, target) {
-  const current = ctx.bindings.get(binding);
-  if (current) {
-    modules.push(current);
-  } 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]);
+function getBindingDependencies(path2, identifiers, isPure) {
+  const bindings = {
+    modules: [],
+    locals: [],
+    mutations: []
+  };
+  for (const identifier5 of identifiers) {
+    const target = path2.scope.getBinding(identifier5);
+    if (target) {
+      extractDependency(bindings, target, isPure);
+    } else {
     }
-  } else if (isPathValid(target.path, t7.isFunctionDeclaration)) {
-    const definition = splitFunctionDeclaration(ctx, target.path);
-    modules.push(definition);
-    ctx.bindings.set(definition.local, definition);
   }
-}
-function registerBinding(ctx, modules, locals, mutations, binding, target, pure) {
-  if (target.kind === "module") {
-    const result = getModuleDefinition(target.path);
-    if (result) {
-      modules.push(result);
+  return bindings;
+}
+function patchIdentifier(dependencies, identifier5, path2) {
+  const binding = path2.scope.getBinding(path2.node.name);
+  if (binding) {
+    const localsIndex = dependencies.locals.indexOf(binding);
+    if (localsIndex > -1) {
+      path2.replaceWith(
+        t5.memberExpression(
+          t5.memberExpression(identifier5, t5.identifier("l")),
+          t5.numericLiteral(localsIndex),
+          true
+        )
+      );
+      return;
     }
-  } else if (target.kind === "param") {
-    locals.push(target.identifier);
-  } else {
-    let blockParent = target.path.scope.getBlockParent();
-    const programParent = target.path.scope.getProgramParent();
-    if (blockParent.path === target.path) {
-      blockParent = blockParent.parent;
+    const mutationsIndex = dependencies.mutations.indexOf(binding);
+    if (mutationsIndex > -1) {
+      path2.replaceWith(
+        t5.memberExpression(
+          t5.memberExpression(identifier5, t5.identifier("m")),
+          t5.numericLiteral(mutationsIndex),
+          true
+        )
+      );
     }
-    if (blockParent === programParent) {
-      registerModuleLevelBinding(ctx, modules, binding, target);
-    } else if (!pure) {
-      locals.push(target.identifier);
-      if (isMutation(target.kind)) {
-        mutations.push(target.identifier);
-      }
+  }
+}
+function patchArrayPattern(dependencies, context, path2) {
+  for (const element of path2.get("elements")) {
+    if (isPathValid(element, t5.isLVal)) {
+      patchLVal(dependencies, context, element);
     }
   }
 }
-function extractBindings(ctx, path2, bindings, pure) {
-  const modules = [];
-  const locals = [];
-  const mutations = [];
-  for (const binding of bindings) {
-    const target = path2.scope.getBinding(binding);
-    if (target) {
-      registerBinding(ctx, modules, locals, mutations, binding, target, pure);
+function patchObjectPattern(dependencies, context, path2) {
+  for (const property of path2.get("properties")) {
+    if (isPathValid(property, t5.isRestElement)) {
+      patchLVal(dependencies, context, property.get("argument"));
+    } else if (isPathValid(property, t5.isObjectProperty)) {
+      const key = property.get("key");
+      if (isPathValid(key, t5.isIdentifier) && property.node.shorthand) {
+        patchLVal(dependencies, context, key);
+        return;
+      }
+      const value = property.get("value");
+      if (isPathValid(value, t5.isLVal)) {
+        patchLVal(dependencies, context, value);
+      }
     }
   }
-  return {
-    modules,
-    locals,
-    mutations
-  };
+}
+function patchLVal(dependencies, context, path2) {
+  if (isPathValid(path2, t5.isArrayPattern)) {
+    patchArrayPattern(dependencies, context, path2);
+  } else if (isPathValid(path2, t5.isAssignmentPattern)) {
+    patchLVal(dependencies, context, path2.get("left"));
+  } else if (isPathValid(path2, t5.isIdentifier)) {
+    patchIdentifier(dependencies, context, path2);
+  } else if (isPathValid(path2, t5.isObjectPattern)) {
+    patchObjectPattern(dependencies, context, path2);
+  } else if (isPathValid(path2, t5.isRestElement)) {
+    patchLVal(dependencies, context, path2.get("argument"));
+  }
+}
+function transformInnerReferences(body, context, dependencies) {
+  body.traverse({
+    ReferencedIdentifier(path2) {
+      patchIdentifier(dependencies, context, path2);
+    },
+    AssignmentExpression(path2) {
+      const left = path2.get("left");
+      if (isPathValid(left, t5.isLVal)) {
+        patchLVal(dependencies, context, left);
+      }
+    },
+    ForXStatement(path2) {
+      const left = path2.get("left");
+      if (isPathValid(left, t5.isLVal)) {
+        patchLVal(dependencies, context, left);
+      }
+    },
+    UpdateExpression(path2) {
+      const id = unwrapPath(path2.get("argument"), t5.isIdentifier);
+      if (id) {
+        patchIdentifier(dependencies, context, id);
+      }
+    }
+  });
 }
 function createVirtualFileName(ctx) {
-  return `./${ctx.path.base}?${ctx.options.key}=${ctx.virtual.count++}${ctx.path.ext}`;
+  return `./${ctx.path.base}?mode=${ctx.options.mode}&${ctx.options.key}=${ctx.virtual.count++}${ctx.path.ext}`;
+}
+function getModuleImports(modules) {
+  const statements = [];
+  for (const mod of modules) {
+    statements.push(moduleDefinitionToImportDeclaration(mod));
+  }
+  return statements;
 }
-function createRootFile(ctx, bindings, replacement) {
+function createRootFile(ctx, statements) {
   const rootFile = createVirtualFileName(ctx);
-  const rootContent = generateCode(
-    ctx.id,
-    t7.program([
-      ...ctx.options.mode === "server" ? moduleDefinitionsToImportDeclarations(bindings.modules) : [],
-      t7.exportDefaultDeclaration(replacement)
-    ])
-  );
+  const node = t5.file(t5.program(statements));
+  patchV8Identifier(ctx, node);
+  const rootContent = generateCode(ctx.id, node);
   ctx.onVirtualFile(
     rootFile,
     { code: rootContent.code, map: rootContent.map },
@@ -427,12 +495,12 @@ function createRootFile(ctx, bindings, replacement) {
   );
   return rootFile;
 }
-function createEntryFile(ctx, path2, rootFile, imported, idPrefix) {
+function createEntryFile(ctx, type, path2, rootFile, imported, idPrefix) {
   let id = `${idPrefix || ""}${ctx.blocks.hash}-${ctx.blocks.count++}`;
   if (ctx.options.env !== "production") {
     id += `-${getDescriptiveName(path2, "anonymous")}`;
   }
-  const entryID = generateUniqueName(path2, "entry");
+  const entryID = t5.identifier("entry");
   const entryImports = [
     {
       kind: imported.kind,
@@ -441,22 +509,37 @@ function createEntryFile(ctx, path2, rootFile, imported, idPrefix) {
       imported: imported.kind === "named" ? imported.name : void 0
     }
   ];
-  const args = [t7.stringLiteral(id)];
+  const args = [t5.stringLiteral(id)];
   if (rootFile) {
-    const rootID = generateUniqueName(path2, "root");
+    const rootID = t5.identifier("root");
     entryImports.push({
       kind: "default",
       source: rootFile,
       local: rootID.name
     });
-    args.push(rootID);
+    const wrapper = t5.identifier("wrapper");
+    let keyword;
+    if (type === "block") {
+      keyword = "$$wrapBlock";
+    } else if (type === "function") {
+      keyword = "$$wrapFunction";
+    } else {
+      keyword = "$$wrapGenerator";
+    }
+    entryImports.push({
+      kind: "named",
+      source: ctx.options.runtime,
+      local: wrapper.name,
+      imported: keyword
+    });
+    args.push(t5.callExpression(wrapper, [rootID]));
   }
   const entryFile = createVirtualFileName(ctx);
   const entryContent = generateCode(
     ctx.id,
-    t7.program([
+    t5.program([
       ...moduleDefinitionsToImportDeclarations(entryImports),
-      t7.exportDefaultDeclaration(t7.callExpression(entryID, args))
+      t5.exportDefaultDeclaration(t5.callExpression(entryID, args))
     ])
   );
   ctx.onVirtualFile(
@@ -466,111 +549,54 @@ function createEntryFile(ctx, path2, rootFile, imported, idPrefix) {
   );
   return entryFile;
 }
-function splitFunctionDeclaration(ctx, path2) {
-  const bindings = getForeignBindings(path2, "function");
-  const { modules } = extractBindings(ctx, path2, bindings);
-  const file = createVirtualFileName(ctx);
-  const compiled = generateCode(
-    ctx.id,
-    t7.program([
-      ...moduleDefinitionsToImportDeclarations(modules),
-      t7.exportNamedDeclaration(path2.node)
-    ])
-  );
-  ctx.onVirtualFile(file, { code: compiled.code, map: compiled.map }, "none");
-  const statement = getRootStatementPath(path2);
-  const identifier7 = path2.node.id || generateUniqueName(path2, "func");
-  const definition = {
-    kind: "named",
-    local: identifier7.name,
-    source: file
-  };
-  statement.insertBefore(moduleDefinitionToImportDeclaration(definition));
-  path2.remove();
-  return definition;
-}
-function splitVariableDeclarator(ctx, path2) {
-  const init = unwrapPath(path2.get("init"), t7.isExpression);
-  const modules = init ? extractBindings(
-    ctx,
-    path2,
-    getForeignBindings(
-      path2,
-      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,
-    t7.program([
-      ...moduleDefinitionsToImportDeclarations(modules),
-      t7.exportNamedDeclaration(t7.variableDeclaration(parent.kind, [path2.node]))
-    ])
-  );
-  ctx.onVirtualFile(file, { code: compiled.code, map: compiled.map }, "none");
-  const definitions = getIdentifiersFromLVal(
-    path2.node.id
-  ).map((name) => ({
-    kind: "named",
-    local: name,
-    source: file
-  }));
-  const statement = getRootStatementPath(path2);
-  if (statement) {
-    statement.insertBefore(moduleDefinitionsToImportDeclarations(definitions));
-  }
-  path2.remove();
-  return definitions;
-}
-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);
+var BREAK_KEY = t5.numericLiteral(0);
+var CONTINUE_KEY = t5.numericLiteral(1);
+var RETURN_KEY = t5.numericLiteral(2);
+var NO_HALT_KEY = t5.numericLiteral(3);
+var THROW_KEY = t5.numericLiteral(4);
+var YIELD_KEY = t5.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),
+    t5.variableDeclaration("let", [
+      t5.variableDeclarator(step),
       // First, get the iterator by calling the generator
-      t7.variableDeclarator(
+      t5.variableDeclarator(
         iterator,
-        t7.awaitExpression(t7.callExpression(registerID, args))
+        t5.awaitExpression(t5.callExpression(registerID, args))
       )
     ]),
     // Create a while statement, the intent is to
     // repeatedly iterate the generator
-    t7.whileStatement(
-      t7.booleanLiteral(true),
-      t7.blockStatement([
+    t5.whileStatement(
+      t5.booleanLiteral(true),
+      t5.blockStatement([
         // Get the next value
-        t7.expressionStatement(
-          t7.assignmentExpression(
+        t5.expressionStatement(
+          t5.assignmentExpression(
             "=",
             step,
-            t7.awaitExpression(
-              t7.callExpression(
-                t7.memberExpression(iterator, t7.identifier("next")),
+            t5.awaitExpression(
+              t5.callExpression(
+                t5.memberExpression(iterator, t5.identifier("next")),
                 []
               )
             )
           )
         ),
         // Check if the step is done
-        t7.ifStatement(
-          t7.memberExpression(step, t7.identifier("done")),
-          t7.blockStatement([
+        t5.ifStatement(
+          t5.memberExpression(step, t5.identifier("done")),
+          t5.blockStatement([
             // exit the loop
-            t7.breakStatement()
+            t5.breakStatement()
           ]),
           // Otherwise, yield the value
-          t7.blockStatement([
-            t7.expressionStatement(
-              t7.yieldExpression(
-                t7.memberExpression(step, t7.identifier("value"))
+          t5.blockStatement([
+            t5.expressionStatement(
+              t5.yieldExpression(
+                t5.memberExpression(step, t5.identifier("value"))
               )
             )
           ])
@@ -580,108 +606,375 @@ function getGeneratorReplacementForBlock(path2, registerID, args) {
   ];
   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)
+function transformRootFunction(root, dependencies) {
+  if (dependencies.locals.length === 0 && dependencies.mutations.length === 0) {
+    return t5.exportDefaultDeclaration(root.node);
+  }
+  const path2 = root.get("body");
+  const context = generateUniqueName(root, "ctx");
+  transformInnerReferences(path2, context, dependencies);
+  const newStatement = isPathValid(path2, t5.isExpression) ? t5.blockStatement([t5.returnStatement(path2.node)]) : path2.node;
+  const statements = t5.blockStatement([
+    t5.variableDeclaration("const", [
+      t5.variableDeclarator(
+        context,
+        t5.callExpression(t5.v8IntrinsicIdentifier(DISMANTLE_CONTEXT), [])
       )
-    )[0]
+    ]),
+    newStatement
+  ]);
+  return t5.exportDefaultDeclaration(
+    t5.isFunctionExpression(root.node) ? t5.functionExpression(
+      root.node.id,
+      root.node.params,
+      statements,
+      root.node.generator,
+      root.node.async
+    ) : t5.arrowFunctionExpression(
+      root.node.params,
+      statements,
+      root.node.async
+    )
   );
-  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 = [];
-  let breakCount = 0;
-  const continues = [];
-  let continueCount = 0;
-  let hasReturn = false;
-  let hasYield = false;
-  const applyMutations = mutations.length ? generateUniqueName(path2, "mutate") : void 0;
-  path2.traverse({
-    BreakStatement(child) {
-      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
-      if (parent === target) {
-        const replacement = [BREAK_KEY];
-        breakCount++;
-        if (child.node.label) {
-          const targetName = child.node.label.name;
-          breaks.push(targetName);
-          replacement.push(t9.stringLiteral(targetName));
-        } else {
-          replacement.push(t9.nullLiteral());
-        }
-        if (applyMutations) {
-          replacement.push(t9.callExpression(applyMutations, []));
-        }
-        child.replaceWith(t9.returnStatement(t9.arrayExpression(replacement)));
-        child.skip();
-      }
-    },
-    ContinueStatement(child) {
-      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
-      if (parent === target) {
-        const replacement = [CONTINUE_KEY];
-        continueCount++;
-        if (child.node.label) {
-          const targetName = child.node.label.name;
-          continues.push(targetName);
-          replacement.push(t9.stringLiteral(targetName));
-        } else {
-          replacement.push(t9.nullLiteral());
-        }
-        if (applyMutations) {
-          replacement.push(t9.callExpression(applyMutations, []));
-        }
-        child.replaceWith(t9.returnStatement(t9.arrayExpression(replacement)));
-        child.skip();
-      }
-    },
-    ReturnStatement(child) {
-      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
-      if (parent === target) {
-        hasReturn = true;
-        const arg = child.get("argument");
-        arg.replaceWith(
-          t9.arrayExpression([
-            RETURN_KEY,
-            arg.node ? arg.node : t9.nullLiteral(),
-            applyMutations ? t9.callExpression(applyMutations, []) : t9.nullLiteral()
-          ])
-        );
-      }
-    },
-    YieldExpression(child) {
-      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
-      if (parent === target) {
-        hasYield = true;
-        if (child.node.delegate) {
-        } else {
-          const arg = child.get("argument");
-          arg.replaceWith(
-            t9.arrayExpression([
-              YIELD_KEY,
-              arg.node ? arg.node : t9.nullLiteral(),
-              applyMutations ? t9.callExpression(applyMutations, []) : t9.nullLiteral()
+function getFunctionReplacement(ctx, path2, entryFile, dependencies) {
+  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(
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          funcID,
+          t5.callExpression(
+            getImportIdentifier(ctx.imports, path2, {
+              ...HIDDEN_GENERATOR,
+              source: ctx.options.runtime
+            }),
+            [
+              source,
+              dependencies.mutations.length ? t5.arrowFunctionExpression(
+                [returnMutations],
+                t5.assignmentExpression(
+                  "=",
+                  t5.arrayPattern(
+                    dependencies.mutations.map((id) => id.identifier)
+                  ),
+                  returnMutations
+                )
+              ) : t5.nullLiteral()
+            ]
+          )
+        )
+      ])
+    );
+    const [reps, step] = getGeneratorReplacementForBlock(path2, funcID, [
+      t5.objectExpression([
+        t5.objectProperty(
+          t5.identifier("l"),
+          t5.arrayExpression(dependencies.locals.map((id) => id.identifier))
+        ),
+        t5.objectProperty(
+          t5.identifier("m"),
+          t5.arrayExpression(dependencies.mutations.map((id) => id.identifier))
+        )
+      ]),
+      t5.spreadElement(rest)
+    ]);
+    for (let i = 0, len = reps.length; i < len; i++) {
+      replacement.push(reps[i]);
+    }
+    replacement.push(
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          t5.arrayPattern([returnType, returnResult]),
+          t5.memberExpression(step, t5.identifier("value"))
+        )
+      ])
+    );
+  } else {
+    replacement.push(
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          t5.arrayPattern([returnType, returnResult]),
+          t5.awaitExpression(
+            t5.callExpression(
+              t5.callExpression(
+                getImportIdentifier(ctx.imports, path2, {
+                  ...HIDDEN_FUNC,
+                  source: ctx.options.runtime
+                }),
+                [
+                  source,
+                  dependencies.mutations.length ? t5.arrowFunctionExpression(
+                    [returnMutations],
+                    t5.assignmentExpression(
+                      "=",
+                      t5.arrayPattern(
+                        dependencies.mutations.map((id) => id.identifier)
+                      ),
+                      returnMutations
+                    )
+                  ) : t5.nullLiteral()
+                ]
+              ),
+              [
+                t5.objectExpression([
+                  t5.objectProperty(
+                    t5.identifier("l"),
+                    t5.arrayExpression(
+                      dependencies.locals.map((id) => id.identifier)
+                    )
+                  ),
+                  t5.objectProperty(
+                    t5.identifier("m"),
+                    t5.arrayExpression(
+                      dependencies.mutations.map((id) => id.identifier)
+                    )
+                  )
+                ]),
+                t5.spreadElement(rest)
+              ]
+            )
+          )
+        )
+      ])
+    );
+  }
+  replacement.push(t5.returnStatement(returnResult));
+  return t5.arrowFunctionExpression(
+    [],
+    t5.blockStatement([
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          source,
+          t5.memberExpression(
+            t5.awaitExpression(t5.importExpression(t5.stringLiteral(entryFile))),
+            t5.identifier("default")
+          )
+        )
+      ]),
+      t5.returnStatement(
+        isPathValid(path2, t5.isFunctionExpression) ? t5.functionExpression(
+          path2.node.id,
+          [t5.restElement(rest)],
+          t5.blockStatement(replacement),
+          path2.node.generator,
+          true
+        ) : t5.arrowFunctionExpression(
+          [t5.restElement(rest)],
+          t5.blockStatement(replacement),
+          true
+        )
+      )
+    ]),
+    true
+  );
+}
+
+// src/utils/get-foreign-bindings.ts
+var t6 = __toESM(require("@babel/types"), 1);
+function isForeignBinding(checker, current, name) {
+  if (current.hasGlobal(name)) {
+    return false;
+  }
+  if (current.hasOwnBinding(name)) {
+    if (checker.mode === "block" && current === checker.root) {
+      const binding = current.getOwnBinding(name);
+      if (binding && binding.kind === "param") {
+        return true;
+      }
+    }
+    return false;
+  }
+  if (checker.root === current) {
+    return true;
+  }
+  if (current.parent) {
+    return isForeignBinding(checker, current.parent, name);
+  }
+  return true;
+}
+function isInTypescript(path2) {
+  let parent = path2.parentPath;
+  while (parent) {
+    if (t6.isTypeScript(parent.node) && !t6.isExpression(parent.node)) {
+      return true;
+    }
+    parent = parent.parentPath;
+  }
+  return false;
+}
+function checkArrayPattern(checker, scope, node) {
+  for (const element of node.elements) {
+    if (element && t6.isLVal(element)) {
+      checkLVal(checker, scope, element);
+    }
+  }
+}
+function checkIdentifier(checker, scope, node) {
+  if (isForeignBinding(checker, scope, node.name)) {
+    checker.ids.add(node.name);
+  }
+}
+function checkObjectPattern(checker, scope, node) {
+  for (const property of node.properties) {
+    if (t6.isRestElement(property)) {
+      checkLVal(checker, scope, property.argument);
+    } else if (t6.isIdentifier(property.key)) {
+      if (property.shorthand) {
+        checkLVal(checker, scope, property.key);
+      } else if (t6.isLVal(property.value)) {
+        checkLVal(checker, scope, property.value);
+      }
+    } else if (t6.isLVal(property.value)) {
+      checkLVal(checker, scope, property.value);
+    }
+  }
+}
+function checkLVal(checker, scope, node) {
+  switch (node.type) {
+    case "ArrayPattern":
+      checkArrayPattern(checker, scope, node);
+      break;
+    case "AssignmentPattern":
+      checkLVal(checker, scope, node.left);
+      break;
+    case "Identifier":
+      checkIdentifier(checker, scope, node);
+      break;
+    case "MemberExpression":
+      break;
+    case "ObjectPattern":
+      checkObjectPattern(checker, scope, node);
+      break;
+    case "RestElement":
+      checkLVal(checker, scope, node.argument);
+      break;
+    case "TSAsExpression":
+      break;
+    case "TSSatisfiesExpression":
+      break;
+    case "TSNonNullExpression":
+      break;
+    case "TSTypeAssertion":
+      break;
+    case "TSParameterProperty":
+      break;
+  }
+}
+function getForeignBindings(path2, mode) {
+  const checker = {
+    ids: /* @__PURE__ */ new Set(),
+    root: path2.scope,
+    mode
+  };
+  path2.traverse({
+    ReferencedIdentifier(p) {
+      if (!isInTypescript(p) && isForeignBinding(checker, p.scope, p.node.name)) {
+        checker.ids.add(p.node.name);
+      }
+    },
+    AssignmentExpression(p) {
+      if (t6.isLVal(p.node.left)) {
+        checkLVal(checker, p.scope, p.node.left);
+      }
+    },
+    ForXStatement(p) {
+      if (t6.isLVal(p.node.left)) {
+        checkLVal(checker, p.scope, p.node.left);
+      }
+    },
+    UpdateExpression(p) {
+      const id = unwrapPath(p.get("argument"), t6.isIdentifier);
+      if (id) {
+        checkIdentifier(checker, p.scope, id.node);
+      }
+    }
+  });
+  return checker.ids;
+}
+
+// src/split-block-directive.ts
+function transformBlockContent(path2, dependencies) {
+  const target = path2.scope.getFunctionParent() || path2.scope.getProgramParent();
+  const breaks = [];
+  let breakCount = 0;
+  const continues = [];
+  let continueCount = 0;
+  let hasReturn = false;
+  let hasYield = false;
+  const context = generateUniqueName(path2, "ctx");
+  const applyMutations = dependencies.mutations.length ? t7.memberExpression(context, t7.identifier("m")) : void 0;
+  path2.traverse({
+    BreakStatement(child) {
+      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
+      if (parent === target) {
+        const replacement = [BREAK_KEY];
+        breakCount++;
+        if (child.node.label) {
+          const targetName = child.node.label.name;
+          breaks.push(targetName);
+          replacement.push(t7.stringLiteral(targetName));
+        } else {
+          replacement.push(t7.nullLiteral());
+        }
+        if (applyMutations) {
+          replacement.push(applyMutations);
+        }
+        child.replaceWith(t7.returnStatement(t7.arrayExpression(replacement)));
+        child.skip();
+      }
+    },
+    ContinueStatement(child) {
+      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
+      if (parent === target) {
+        const replacement = [CONTINUE_KEY];
+        continueCount++;
+        if (child.node.label) {
+          const targetName = child.node.label.name;
+          continues.push(targetName);
+          replacement.push(t7.stringLiteral(targetName));
+        } else {
+          replacement.push(t7.nullLiteral());
+        }
+        if (applyMutations) {
+          replacement.push(applyMutations);
+        }
+        child.replaceWith(t7.returnStatement(t7.arrayExpression(replacement)));
+        child.skip();
+      }
+    },
+    ReturnStatement(child) {
+      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
+      if (parent === target) {
+        hasReturn = true;
+        const arg = child.get("argument");
+        arg.replaceWith(
+          t7.arrayExpression([
+            RETURN_KEY,
+            arg.node ? arg.node : t7.nullLiteral(),
+            applyMutations ? applyMutations : t7.nullLiteral()
+          ])
+        );
+      }
+    },
+    YieldExpression(child) {
+      const parent = child.scope.getFunctionParent() || child.scope.getProgramParent();
+      if (parent === target) {
+        hasYield = true;
+        if (child.node.delegate) {
+        } else {
+          const arg = child.get("argument");
+          arg.replaceWith(
+            t7.arrayExpression([
+              YIELD_KEY,
+              arg.node ? arg.node : t7.nullLiteral(),
+              applyMutations ? applyMutations : t7.nullLiteral()
             ])
           );
         }
@@ -692,56 +985,54 @@ function transformBlockContent(path2, mutations) {
   const throwResult = [THROW_KEY, error];
   const haltResult = [NO_HALT_KEY];
   if (applyMutations) {
-    throwResult.push(t9.callExpression(applyMutations, []));
-    haltResult.push(t9.nullLiteral());
-    haltResult.push(t9.callExpression(applyMutations, []));
-  }
-  const statements = [
-    t9.tryStatement(
-      t9.blockStatement(path2.node.body),
-      t9.catchClause(
-        error,
-        t9.blockStatement([t9.returnStatement(t9.arrayExpression(throwResult))])
-      )
-    ),
-    t9.returnStatement(t9.arrayExpression(haltResult))
-  ];
-  if (applyMutations) {
-    statements.unshift(
-      t9.variableDeclaration("const", [
-        t9.variableDeclarator(
-          applyMutations,
-          t9.arrowFunctionExpression(
-            [],
-            t9.objectExpression(
-              mutations.map((item) => t9.objectProperty(item, item, false, true))
-            )
-          )
-        )
-      ])
-    );
+    throwResult.push(applyMutations);
+    haltResult.push(t7.nullLiteral());
+    haltResult.push(applyMutations);
   }
-  path2.node.body = statements;
-  return { breaks, continues, hasReturn, hasYield, breakCount, continueCount };
+  transformInnerReferences(path2, context, dependencies);
+  return {
+    breaks,
+    continues,
+    hasReturn,
+    hasYield,
+    breakCount,
+    continueCount,
+    block: t7.blockStatement([
+      t7.variableDeclaration("const", [
+        t7.variableDeclarator(
+          context,
+          t7.callExpression(t7.v8IntrinsicIdentifier(DISMANTLE_CONTEXT), [])
+        )
+      ]),
+      t7.tryStatement(
+        t7.blockStatement(path2.node.body),
+        t7.catchClause(
+          error,
+          t7.blockStatement([t7.returnStatement(t7.arrayExpression(throwResult))])
+        )
+      ),
+      t7.returnStatement(t7.arrayExpression(haltResult))
+    ])
+  };
 }
 function getBreakCheck(returnType, returnResult, breakCount, breaks, check) {
   let current;
   if (breakCount !== breaks.length) {
-    current = t9.blockStatement([t9.breakStatement()]);
+    current = t7.blockStatement([t7.breakStatement()]);
   }
   for (let i = 0, len = breaks.length; i < len; i++) {
     const target = breaks[i];
-    current = t9.blockStatement([
-      t9.ifStatement(
-        t9.binaryExpression("===", returnResult, t9.stringLiteral(target)),
-        t9.blockStatement([t9.breakStatement(t9.identifier(target))]),
+    current = t7.blockStatement([
+      t7.ifStatement(
+        t7.binaryExpression("===", returnResult, t7.stringLiteral(target)),
+        t7.blockStatement([t7.breakStatement(t7.identifier(target))]),
         current
       )
     ]);
   }
   if (current) {
-    return t9.ifStatement(
-      t9.binaryExpression("===", returnType, BREAK_KEY),
+    return t7.ifStatement(
+      t7.binaryExpression("===", returnType, BREAK_KEY),
       current,
       check
     );
@@ -751,36 +1042,36 @@ function getBreakCheck(returnType, returnResult, breakCount, breaks, check) {
 function getContinueCheck(returnType, returnResult, continueCount, continues, check) {
   let current;
   if (continueCount !== continues.length) {
-    current = t9.blockStatement([t9.continueStatement()]);
+    current = t7.blockStatement([t7.continueStatement()]);
   }
   for (let i = 0, len = continues.length; i < len; i++) {
     const target = continues[i];
-    current = t9.blockStatement([
-      t9.ifStatement(
-        t9.binaryExpression("===", returnResult, t9.stringLiteral(target)),
-        t9.blockStatement([t9.continueStatement(t9.identifier(target))]),
+    current = t7.blockStatement([
+      t7.ifStatement(
+        t7.binaryExpression("===", returnResult, t7.stringLiteral(target)),
+        t7.blockStatement([t7.continueStatement(t7.identifier(target))]),
         current
       )
     ]);
   }
   if (current) {
-    return t9.ifStatement(
-      t9.binaryExpression("===", returnType, CONTINUE_KEY),
+    return t7.ifStatement(
+      t7.binaryExpression("===", returnType, CONTINUE_KEY),
       current,
       check
     );
   }
   return check;
 }
-function getBlockDirectiveReplacement(ctx, path2, entryFile, bindings, halting) {
+function getBlockDirectiveReplacement(ctx, path2, entryFile, dependencies, halting) {
   const returnType = generateUniqueName(path2, "type");
   const returnResult = generateUniqueName(path2, "result");
   const returnMutations = generateUniqueName(path2, "mutations");
   let check;
   if (halting.hasReturn) {
-    check = t9.ifStatement(
-      t9.binaryExpression("===", returnType, RETURN_KEY),
-      t9.blockStatement([t9.returnStatement(returnResult)]),
+    check = t7.ifStatement(
+      t7.binaryExpression("===", returnType, RETURN_KEY),
+      t7.blockStatement([t7.returnStatement(returnResult)]),
       check
     );
   }
@@ -806,88 +1097,100 @@ function getBlockDirectiveReplacement(ctx, path2, entryFile, bindings, halting)
   if (halting.hasYield) {
     const blockID = generateUniqueName(path2, "block");
     replacement.push(
-      t9.variableDeclaration("const", [
-        t9.variableDeclarator(
+      t7.variableDeclaration("const", [
+        t7.variableDeclarator(
           blockID,
-          t9.callExpression(
-            getImportIdentifier(ctx, path2, {
+          t7.callExpression(
+            getImportIdentifier(ctx.imports, path2, {
               ...HIDDEN_GENERATOR,
               source: ctx.options.runtime
             }),
             [
-              t9.memberExpression(
-                t9.awaitExpression(
-                  t9.importExpression(t9.stringLiteral(entryFile))
+              t7.memberExpression(
+                t7.awaitExpression(
+                  t7.importExpression(t7.stringLiteral(entryFile))
                 ),
-                t9.identifier("default")
+                t7.identifier("default")
               ),
-              bindings.mutations.length ? t9.arrowFunctionExpression(
+              dependencies.mutations.length ? t7.arrowFunctionExpression(
                 [returnMutations],
-                t9.assignmentExpression(
+                t7.assignmentExpression(
                   "=",
-                  t9.objectPattern(
-                    bindings.mutations.map(
-                      (item) => t9.objectProperty(item, item, false, true)
-                    )
+                  t7.arrayPattern(
+                    dependencies.mutations.map((id) => id.identifier)
                   ),
                   returnMutations
                 )
-              ) : t9.nullLiteral()
+              ) : t7.nullLiteral()
             ]
           )
         )
       ])
     );
-    const [reps, step] = getGeneratorReplacementForBlock(
-      path2,
-      blockID,
-      bindings.locals
-    );
+    const [reps, step] = getGeneratorReplacementForBlock(path2, blockID, [
+      t7.arrayExpression([
+        t7.arrayExpression(dependencies.locals.map((id) => id.identifier)),
+        t7.arrayExpression(dependencies.mutations.map((id) => id.identifier))
+      ])
+    ]);
     for (let i = 0, len = reps.length; i < len; i++) {
       replacement.push(reps[i]);
     }
     replacement.push(
-      t9.variableDeclaration("const", [
-        t9.variableDeclarator(
-          t9.arrayPattern([returnType, returnResult]),
-          t9.memberExpression(step, t9.identifier("value"))
+      t7.variableDeclaration("const", [
+        t7.variableDeclarator(
+          t7.arrayPattern([returnType, returnResult]),
+          t7.memberExpression(step, t7.identifier("value"))
         )
       ])
     );
   } else {
     replacement.push(
-      t9.variableDeclaration("const", [
-        t9.variableDeclarator(
-          t9.arrayPattern([returnType, returnResult]),
-          t9.awaitExpression(
-            t9.callExpression(
-              t9.callExpression(
-                getImportIdentifier(ctx, path2, {
+      t7.variableDeclaration("const", [
+        t7.variableDeclarator(
+          t7.arrayPattern([returnType, returnResult]),
+          t7.awaitExpression(
+            t7.callExpression(
+              t7.callExpression(
+                getImportIdentifier(ctx.imports, path2, {
                   ...HIDDEN_FUNC,
                   source: ctx.options.runtime
                 }),
                 [
-                  t9.memberExpression(
-                    t9.awaitExpression(
-                      t9.importExpression(t9.stringLiteral(entryFile))
+                  t7.memberExpression(
+                    t7.awaitExpression(
+                      t7.importExpression(t7.stringLiteral(entryFile))
                     ),
-                    t9.identifier("default")
+                    t7.identifier("default")
                   ),
-                  bindings.mutations.length ? t9.arrowFunctionExpression(
+                  dependencies.mutations.length ? t7.arrowFunctionExpression(
                     [returnMutations],
-                    t9.assignmentExpression(
+                    t7.assignmentExpression(
                       "=",
-                      t9.objectPattern(
-                        bindings.mutations.map(
-                          (item) => t9.objectProperty(item, item, false, true)
-                        )
+                      t7.arrayPattern(
+                        dependencies.mutations.map((id) => id.identifier)
                       ),
                       returnMutations
                     )
-                  ) : t9.nullLiteral()
+                  ) : t7.nullLiteral()
                 ]
               ),
-              bindings.locals
+              [
+                t7.objectExpression([
+                  t7.objectProperty(
+                    t7.identifier("l"),
+                    t7.arrayExpression(
+                      dependencies.locals.map((id) => id.identifier)
+                    )
+                  ),
+                  t7.objectProperty(
+                    t7.identifier("m"),
+                    t7.arrayExpression(
+                      dependencies.mutations.map((id) => id.identifier)
+                    )
+                  )
+                ])
+              ]
             )
           )
         )
@@ -897,78 +1200,83 @@ function getBlockDirectiveReplacement(ctx, path2, entryFile, bindings, halting)
   if (check) {
     replacement.push(check);
   }
-  return t9.blockStatement(replacement);
+  return replacement;
 }
-function replaceBlockDirective(ctx, path2, directive, bindings) {
-  const halting = transformBlockContent(path2, bindings.mutations);
-  const entryFile = createEntryFile(
-    ctx,
-    path2,
-    ctx.options.mode === "server" || directive.isomorphic ? createRootFile(
-      ctx,
-      bindings,
-      t9.functionExpression(
+function replaceBlockDirective(ctx, path2, directive, dependencies) {
+  const original = path2.node;
+  path2.node = t7.cloneNode(path2.node, true, false);
+  const halting = transformBlockContent(path2, dependencies);
+  const statements = getModuleImports(dependencies.modules);
+  statements.push(
+    t7.exportDefaultDeclaration(
+      t7.functionExpression(
         void 0,
-        bindings.locals,
-        t9.blockStatement(path2.node.body),
+        [],
+        halting.block,
         halting.hasYield,
         true
       )
-    ) : void 0,
+    )
+  );
+  const entryFile = createEntryFile(
+    ctx,
+    "block",
+    path2,
+    ctx.options.mode === "server" ? createRootFile(ctx, statements) : void 0,
     directive.target,
     directive.idPrefix
   );
-  path2.replaceWith(
-    getBlockDirectiveReplacement(ctx, path2, entryFile, bindings, halting)
+  const result = getBlockDirectiveReplacement(
+    ctx,
+    path2,
+    entryFile,
+    dependencies,
+    halting
   );
+  path2.node = original;
+  return result;
 }
 function splitBlockDirective(ctx, path2, directive) {
-  replaceBlockDirective(
+  return replaceBlockDirective(
     ctx,
     path2,
     directive,
-    extractBindings(
-      ctx,
+    getBindingDependencies(
       path2,
       getForeignBindings(path2, "block"),
-      directive.pure
+      !!directive.pure
     )
   );
 }
 
 // src/utils/directive-check.ts
-var t10 = __toESM(require("@babel/types"), 1);
-function getValidDirectiveFromString(ctx, string) {
+var t8 = __toESM(require("@babel/types"), 1);
+function getValidDirectiveFromString(ctx, type, 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;
-      }
+    if (current.type === type && current.directive === string) {
+      return current;
     }
   }
   return void 0;
 }
-function getDefinitionFromDirectives(ctx, path2) {
+function getDefinitionFromDirectives(ctx, type, 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);
+    const directive = getValidDirectiveFromString(ctx, type, statement);
     if (directive) {
       return directive;
     }
   }
   return void 0;
 }
-function getDefinitionFromFauxDirectives(ctx, path2) {
+function getDefinitionFromFauxDirectives(ctx, type, 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)) {
+    if (t8.isExpressionStatement(statement) && t8.isStringLiteral(statement.expression)) {
       const directive = getValidDirectiveFromString(
         ctx,
+        type,
         statement.expression.value
       );
       if (directive) {
@@ -980,14 +1288,7 @@ function getDefinitionFromFauxDirectives(ctx, path2) {
   }
   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) {
+function cleanDirectives(path2, definition) {
   const newDirectives = [];
   for (let i = 0, len = path2.node.directives.length; i < len; i++) {
     const current = path2.node.directives[i];
@@ -997,11 +1298,11 @@ function cleanBlockForDirectives(path2, definition) {
   }
   path2.node.directives = newDirectives;
 }
-function cleanBlockForFauxDirectives(path2, definition) {
+function cleanFauxDirectives(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 (t8.isExpressionStatement(statement.node) && t8.isStringLiteral(statement.node.expression)) {
       if (statement.node.expression.value === definition.directive) {
         statement.remove();
         return;
@@ -1011,347 +1312,67 @@ function cleanBlockForFauxDirectives(path2, definition) {
 }
 
 // src/transform-block-directive.ts
-function transformBlockDirective(ctx, path2) {
-  const definition = getDirectiveDefinitionFromBlock(ctx, path2);
-  if (!definition || definition.type !== "block-directive") {
-    return;
+function getBlockDirectiveDefinition(ctx, path2) {
+  const definition = getDefinitionFromDirectives(ctx, "block-directive", path2);
+  if (definition) {
+    cleanDirectives(path2, definition);
+    return definition;
   }
-  cleanBlockForDirectives(path2, definition);
-  cleanBlockForFauxDirectives(path2, definition);
-  splitBlockDirective(ctx, path2, definition);
+  const fauxDefinition = getDefinitionFromFauxDirectives(
+    ctx,
+    "block-directive",
+    path2
+  );
+  if (fauxDefinition) {
+    cleanFauxDirectives(path2, fauxDefinition);
+    return fauxDefinition;
+  }
+  return void 0;
 }
-
-// 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);
+function transformBlockDirective(ctx, path2) {
+  const definition = getBlockDirectiveDefinition(ctx, path2);
+  if (definition) {
+    path2.node.body = splitBlockDirective(ctx, path2, definition);
+    path2.scope.crawl();
   }
 }
 
-// src/split-call.ts
-function transformFunctionContent(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(t11.nullLiteral());
-        }
-        if (applyMutations) {
-          replacement.push(t11.callExpression(applyMutations, []));
-        }
-        child.replaceWith(t11.returnStatement(t11.arrayExpression(replacement)));
-        child.skip();
-      }
-    }
-  });
-  const error = generateUniqueName(path2, "error");
-  const throwResult = [THROW_KEY, error];
-  const haltResult = [NO_HALT_KEY];
-  if (applyMutations) {
-    throwResult.push(t11.callExpression(applyMutations, []));
-    haltResult.push(t11.nullLiteral());
-    haltResult.push(t11.callExpression(applyMutations, []));
-  }
-  const statements = [
-    t11.tryStatement(
-      t11.blockStatement(path2.node.body),
-      t11.catchClause(
-        error,
-        t11.blockStatement([t11.returnStatement(t11.arrayExpression(throwResult))])
-      )
-    ),
-    t11.returnStatement(t11.arrayExpression(haltResult))
-  ];
-  if (applyMutations) {
-    statements.unshift(
-      t11.variableDeclaration("const", [
-        t11.variableDeclarator(
-          applyMutations,
-          t11.arrowFunctionExpression(
-            [],
-            t11.objectExpression(
-              mutations.map((item) => t11.objectProperty(item, item, false, true))
-            )
-          )
-        )
-      ])
-    );
-  }
-  path2.node.body = statements;
-}
-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 (path2.node.generator) {
-    const funcID = generateUniqueName(path2, "fn");
-    replacement.push(
-      t11.variableDeclaration("const", [
-        t11.variableDeclarator(
-          funcID,
-          t11.callExpression(
-            getImportIdentifier(ctx, path2, {
-              ...HIDDEN_GENERATOR,
-              source: ctx.options.runtime
-            }),
-            [
-              source,
-              bindings.mutations.length ? t11.arrowFunctionExpression(
-                [returnMutations],
-                t11.assignmentExpression(
-                  "=",
-                  t11.objectPattern(
-                    bindings.mutations.map(
-                      (item) => t11.objectProperty(item, item, false, true)
-                    )
-                  ),
-                  returnMutations
-                )
-              ) : t11.nullLiteral()
-            ]
-          )
-        )
-      ])
-    );
-    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(
-      t11.variableDeclaration("const", [
-        t11.variableDeclarator(
-          t11.arrayPattern([returnType, returnResult]),
-          t11.memberExpression(step, t11.identifier("value"))
-        )
-      ])
-    );
-  } else {
-    replacement.push(
-      t11.variableDeclaration("const", [
-        t11.variableDeclarator(
-          t11.arrayPattern([returnType, returnResult]),
-          t11.awaitExpression(
-            t11.callExpression(
-              t11.callExpression(
-                getImportIdentifier(ctx, path2, {
-                  ...HIDDEN_FUNC,
-                  source: ctx.options.runtime
-                }),
-                [
-                  source,
-                  bindings.mutations.length ? t11.arrowFunctionExpression(
-                    [returnMutations],
-                    t11.assignmentExpression(
-                      "=",
-                      t11.objectPattern(
-                        bindings.mutations.map(
-                          (item) => t11.objectProperty(item, item, false, true)
-                        )
-                      ),
-                      returnMutations
-                    )
-                  ) : t11.nullLiteral()
-                ]
-              ),
-              [t11.arrayExpression(bindings.locals), t11.spreadElement(rest)]
-            )
-          )
-        )
-      ])
-    );
-  }
-  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)]));
-  }
-  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,
-    func.idPrefix
-  );
-  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 replaceFunctionFromCall(ctx, path2, func, bindings) {
-  const body = path2.get("body");
-  if (isPathValid(body, t11.isExpression)) {
-    body.replaceWith(t11.blockStatement([t11.returnStatement(body.node)]));
-  }
-  assert(isPathValid(body, t11.isBlockStatement), "invariant");
-  transformFunctionContent(body, bindings.mutations);
-  const entryFile = createEntryFile(
-    ctx,
-    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,
-    func.idPrefix
-  );
-  return getFunctionReplacement(ctx, path2, entryFile, bindings);
-}
-function splitFunctionFromCall(ctx, path2, func) {
-  const bindings = extractBindings(
-    ctx,
-    path2,
-    getForeignBindings(path2, "function"),
-    func.pure
-  );
-  if (func.isomorphic) {
-    return replaceIsomorphicFunction(ctx, path2, func, bindings);
-  }
-  return replaceFunctionFromCall(ctx, path2, func, bindings);
-}
-function replaceExpressionFromCall(ctx, path2, func, bindings) {
+// src/transform-call.ts
+var t10 = __toESM(require("@babel/types"), 1);
+
+// src/split-function.ts
+function replaceFunction(ctx, path2, definition, dependencies) {
+  const statements = getModuleImports(dependencies.modules);
+  statements.push(transformRootFunction(path2, dependencies));
   const entryFile = createEntryFile(
     ctx,
+    path2.node.generator ? "generator" : "function",
     path2,
-    ctx.options.mode === "server" || func.isomorphic ? createRootFile(ctx, bindings, path2.node) : void 0,
-    func.target,
-    func.idPrefix
-  );
-  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
+    ctx.options.mode === "server" ? createRootFile(ctx, statements) : void 0,
+    definition.target,
+    definition.idPrefix
   );
+  return getFunctionReplacement(ctx, path2, entryFile, dependencies);
 }
-function splitExpressionFromCall(ctx, path2, func) {
-  return replaceExpressionFromCall(
+function splitFunction(ctx, path2, definition) {
+  return replaceFunction(
     ctx,
     path2,
-    func,
-    extractBindings(
-      ctx,
+    definition,
+    getBindingDependencies(
       path2,
-      getForeignBindings(path2, "expression"),
-      func.pure
+      getForeignBindings(path2, "function"),
+      !!definition.pure
     )
   );
 }
 
+// src/utils/is-valid-function.ts
+var t9 = __toESM(require("@babel/types"), 1);
+function isValidFunction(node) {
+  return t9.isArrowFunctionExpression(node) || t9.isFunctionExpression(node);
+}
+
 // src/transform-call.ts
 function getFunctionDefinitionFromPropName(definitions, propName) {
   for (let i = 0, len = definitions.length; i < len; i++) {
@@ -1367,7 +1388,7 @@ function getFunctionDefinitionFromPropName(definitions, propName) {
 }
 function getFunctionDefinitionFromCallee(ctx, path2) {
   const callee = path2.node.callee;
-  const id = unwrapNode(callee, t12.isIdentifier);
+  const id = unwrapNode(callee, t10.isIdentifier);
   if (id) {
     const binding = path2.scope.getBindingIdentifier(id.name);
     if (binding) {
@@ -1375,9 +1396,9 @@ function getFunctionDefinitionFromCallee(ctx, path2) {
     }
     return void 0;
   }
-  const memberExpr = unwrapNode(callee, t12.isMemberExpression);
-  if (memberExpr && !memberExpr.computed && t12.isIdentifier(memberExpr.property)) {
-    const object = unwrapNode(memberExpr.object, t12.isIdentifier);
+  const memberExpr = unwrapNode(callee, t10.isMemberExpression);
+  if (memberExpr && !memberExpr.computed && t10.isIdentifier(memberExpr.property)) {
+    const object = unwrapNode(memberExpr.object, t10.isIdentifier);
     if (object) {
       const binding = path2.scope.getBindingIdentifier(object.name);
       if (binding) {
@@ -1393,19 +1414,6 @@ function getFunctionDefinitionFromCallee(ctx, path2) {
   }
   return void 0;
 }
-function isValidFunction(node) {
-  return t12.isArrowFunctionExpression(node) || t12.isFunctionExpression(node);
-}
-function isSkippableFunction(node) {
-  if (node.leadingComments) {
-    for (let i = 0, len = node.leadingComments.length; i < len; i++) {
-      if (/^@dismantle skip$/.test(node.leadingComments[i].value)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
 function transformCall(ctx, path2) {
   const definition = getFunctionDefinitionFromCallee(ctx, path2);
   if (!definition) {
@@ -1413,369 +1421,107 @@ function transformCall(ctx, path2) {
   }
   const args = path2.get("arguments");
   const expr = args[0];
-  if (isPathValid(expr, t12.isExpression) && !isSkippableFunction(expr.node)) {
-    const replacement = isPathValid(expr, isValidFunction) ? splitFunctionFromCall(ctx, expr, definition) : splitExpressionFromCall(ctx, expr, definition);
+  if (isPathValid(expr, isValidFunction)) {
+    const replacement = splitFunction(ctx, expr, definition);
+    path2.scope.crawl();
     path2.replaceWith(
-      t12.callExpression(getImportIdentifier(ctx, path2, definition.handle), [
-        t12.addComment(replacement, "leading", "@dismantle skip")
-      ])
+      t10.callExpression(
+        getImportIdentifier(ctx.imports, path2, definition.handle),
+        [replacement]
+      )
     );
   }
 }
 
 // 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: ctx.options.runtime
-            }),
-            [
-              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: ctx.options.runtime
-                }),
-                [
-                  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(
+var t11 = __toESM(require("@babel/types"), 1);
+function getFunctionDirectiveDefinition(ctx, path2) {
+  const definition = getDefinitionFromDirectives(
     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,
-    directive.idPrefix
-  );
-  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-directive",
+    path2
   );
-}
-function replaceFunctionDirective(ctx, path2, directive, bindings) {
-  const body = path2.get("body");
-  if (isPathValid(body, t13.isExpression)) {
-    body.replaceWith(t13.blockStatement([t13.returnStatement(body.node)]));
+  if (definition) {
+    cleanDirectives(path2, definition);
+    return definition;
   }
-  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,
-    directive.idPrefix
-  );
-  return getFunctionReplacement2(ctx, path2, entryFile, bindings);
-}
-function splitFunctionDirective(ctx, path2, directive) {
-  const bindings = extractBindings(
+  const fauxDefinition = getDefinitionFromFauxDirectives(
     ctx,
-    path2,
-    getForeignBindings(path2, "function"),
-    directive.pure
+    "function-directive",
+    path2
   );
-  if (directive.isomorphic) {
-    return replaceIsomorphicFunction2(ctx, path2, directive, bindings);
+  if (fauxDefinition) {
+    cleanFauxDirectives(path2, fauxDefinition);
+    return fauxDefinition;
   }
-  return replaceFunctionDirective(ctx, path2, directive, bindings);
+  return void 0;
 }
-
-// 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;
+  if (isPathValid(body, t11.isBlockStatement)) {
+    const definition = getFunctionDirectiveDefinition(ctx, body);
+    if (definition) {
+      const replacement = splitFunction(ctx, path2, definition);
+      path2.scope.crawl();
+      path2.replaceWith(
+        t11.callExpression(
+          getImportIdentifier(ctx.imports, path2, definition.handle),
+          [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(
+var t12 = __toESM(require("@babel/types"), 1);
+function bubbleFunctionDeclaration(ctx, path2) {
+  const decl = path2.node;
+  if (decl.id) {
+    const definition = getDefinitionFromDirectives(
+      ctx,
+      "function-directive",
+      path2.get("body")
+    );
+    if (!definition) {
+      return;
+    }
+    const block = path2.findParent((current) => current.isBlockStatement()) || path2.scope.getProgramParent().path;
+    const [tmp] = block.unshiftContainer(
+      "body",
+      t12.variableDeclaration("const", [
+        t12.variableDeclarator(
+          decl.id,
+          t12.functionExpression(
             decl.id,
-            t15.functionExpression(
-              decl.id,
-              decl.params,
-              decl.body,
-              decl.generator,
-              decl.async
-            )
+            decl.params,
+            decl.body,
+            decl.generator,
+            decl.async
           )
+        )
+      ])
+    );
+    path2.scope.registerDeclaration(tmp);
+    tmp.skip();
+    if (path2.parentPath.isExportNamedDeclaration()) {
+      path2.parentPath.replaceWith(
+        t12.exportNamedDeclaration(void 0, [
+          t12.exportSpecifier(decl.id, decl.id)
         ])
       );
-      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();
-      }
+    } else if (path2.parentPath.isExportDefaultDeclaration()) {
+      path2.replaceWith(decl.id);
+    } else {
+      path2.remove();
     }
   }
 }
 
 // src/utils/register-import-specifiers.ts
-var t16 = __toESM(require("@babel/types"), 1);
+var t13 = __toESM(require("@babel/types"), 1);
 function registerImportSpecifier(ctx, node, definition) {
-  if (t16.isImportSpecifier(node)) {
+  if (t13.isImportSpecifier(node)) {
     if (node.importKind === "type" || node.importKind === "typeof") {
       return;
     }
@@ -1784,10 +1530,10 @@ function registerImportSpecifier(ctx, node, definition) {
       ctx.registrations.identifiers.set(node.local, definition);
     }
   }
-  if (t16.isImportDefaultSpecifier(node) && definition.source.kind === "default") {
+  if (t13.isImportDefaultSpecifier(node) && definition.source.kind === "default") {
     ctx.registrations.identifiers.set(node.local, definition);
   }
-  if (t16.isImportNamespaceSpecifier(node)) {
+  if (t13.isImportNamespaceSpecifier(node)) {
     let current = ctx.registrations.namespaces.get(node.local);
     if (!current) {
       current = [];
@@ -1823,32 +1569,52 @@ function registerImportSpecifiers(ctx, programPath) {
 }
 
 // src/plugin.ts
-function plugin() {
-  return {
-    name: "dismantle",
-    visitor: {
-      Program(programPath, ctx) {
-        registerImportSpecifiers(ctx.opts, programPath);
-        programPath.traverse({
-          FunctionDeclaration(path2) {
-            bubbleFunctionDeclaration(ctx.opts, programPath, path2);
-          }
-        });
-      },
-      ArrowFunctionExpression(path2, ctx) {
+var FUNCTION_BUBBLE = {
+  FunctionDeclaration(path2, ctx) {
+    bubbleFunctionDeclaration(ctx.opts, path2);
+  }
+};
+var PLUGIN = {
+  name: "dismantle",
+  visitor: {
+    Program: {
+      enter(program2, ctx) {
+        registerImportSpecifiers(ctx.opts, program2);
+        program2.traverse(FUNCTION_BUBBLE, ctx);
+        program2.scope.crawl();
+      }
+    },
+    ArrowFunctionExpression: {
+      exit(path2, ctx) {
         transformFunctionDirective(ctx.opts, path2);
-      },
-      FunctionExpression(path2, ctx) {
+      }
+    },
+    FunctionExpression: {
+      exit(path2, ctx) {
         transformFunctionDirective(ctx.opts, path2);
-      },
-      BlockStatement(path2, ctx) {
+      }
+    },
+    BlockStatement: {
+      exit(path2, ctx) {
         transformBlockDirective(ctx.opts, path2);
-      },
-      CallExpression(path2, ctx) {
+      }
+    },
+    CallExpression: {
+      exit(path2, ctx) {
         transformCall(ctx.opts, path2);
       }
     }
-  };
+  }
+};
+function plugin() {
+  return PLUGIN;
+}
+
+// src/utils/assert.ts
+function assert(cond, error) {
+  if (!cond) {
+    throw new Error(error);
+  }
 }
 
 // src/utils/xxhash32.ts