dismantle 0.2.0

package/dist/cjs/development/index.cjs

@@ -0,0 +1,1484 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  compile: () => compile
+});
+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 t5 = __toESM(require("@babel/types"), 1);
+
+// src/hidden-imports.ts
+var HIDDEN_FUNC = {
+  kind: "named",
+  source: "dismantle/runtime",
+  name: "$$func"
+};
+var HIDDEN_GENERATOR = {
+  kind: "named",
+  source: "dismantle/runtime",
+  name: "$$gen"
+};
+
+// src/utils/assert.ts
+function assert(cond, error) {
+  if (!cond) {
+    throw new Error(error);
+  }
+}
+
+// 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;
+function generateCode(id, node) {
+  const result = generator(node, {
+    sourceMaps: true,
+    sourceFileName: id
+  });
+  return {
+    code: result.code,
+    map: result.map
+  };
+}
+
+// src/utils/get-descriptive-name.ts
+function getDescriptiveName(path2, defaultName) {
+  let current = path2;
+  while (current) {
+    switch (current.node.type) {
+      case "FunctionDeclaration":
+      case "FunctionExpression": {
+        if (current.node.id) {
+          return current.node.id.name;
+        }
+        break;
+      }
+      case "VariableDeclarator": {
+        if (current.node.id.type === "Identifier") {
+          return current.node.id.name;
+        }
+        break;
+      }
+      case "ClassPrivateMethod":
+      case "ClassMethod":
+      case "ObjectMethod": {
+        switch (current.node.key.type) {
+          case "Identifier":
+            return current.node.key.name;
+          case "PrivateName":
+            return current.node.key.id.name;
+          default:
+            break;
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    current = current.parentPath;
+  }
+  return defaultName;
+}
+
+// src/utils/get-foreign-bindings.ts
+var t = __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 (t.isTypeScript(parent.node) && !t.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 t2 = __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 (t2.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-import-identifier.ts
+var import_helper_module_imports = require("@babel/helper-module-imports");
+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 newID = registration.kind === "named" ? (0, import_helper_module_imports.addNamed)(path2, registration.name, registration.source) : (0, import_helper_module_imports.addDefault)(path2, registration.source);
+  state.imports.set(target, newID);
+  return newID;
+}
+
+// src/utils/get-module-definition.ts
+var t3 = __toESM(require("@babel/types"), 1);
+
+// src/utils/get-import-specifier-name.ts
+function getImportSpecifierName(node) {
+  switch (node.imported.type) {
+    case "Identifier":
+      return node.imported.name;
+    case "StringLiteral":
+      return node.imported.value;
+  }
+}
+
+// src/utils/unwrap.ts
+function isPathValid(path2, key) {
+  return key(path2.node);
+}
+function isNestedExpression(node) {
+  switch (node.type) {
+    case "ParenthesizedExpression":
+    case "TypeCastExpression":
+    case "TSAsExpression":
+    case "TSSatisfiesExpression":
+    case "TSNonNullExpression":
+    case "TSTypeAssertion":
+    case "TSInstantiationExpression":
+      return true;
+    default:
+      return false;
+  }
+}
+function unwrapNode(node, key) {
+  if (key(node)) {
+    return node;
+  }
+  if (isNestedExpression(node)) {
+    return unwrapNode(node.expression, key);
+  }
+  return void 0;
+}
+function unwrapPath(path2, key) {
+  if (isPathValid(path2, key)) {
+    return path2;
+  }
+  if (isPathValid(path2, isNestedExpression)) {
+    return unwrapPath(path2.get("expression"), key);
+  }
+  return void 0;
+}
+
+// src/utils/get-module-definition.ts
+function getModuleDefinition(path2) {
+  if (!(isPathValid(path2, t3.isImportSpecifier) || isPathValid(path2, t3.isImportDefaultSpecifier) || isPathValid(path2, t3.isImportNamespaceSpecifier))) {
+    return void 0;
+  }
+  const parent = path2.getStatementParent();
+  const source = parent.node.source.value;
+  switch (path2.node.type) {
+    case "ImportDefaultSpecifier":
+      return {
+        source,
+        kind: "default",
+        local: path2.node.local.name
+      };
+    case "ImportNamespaceSpecifier":
+      return {
+        source,
+        kind: "namespace",
+        local: path2.node.local.name
+      };
+    case "ImportSpecifier": {
+      const imported = getImportSpecifierName(path2.node);
+      if (imported === "default") {
+        return {
+          source,
+          kind: "default",
+          local: path2.node.local.name,
+          imported: ""
+        };
+      }
+      return {
+        source,
+        kind: "named",
+        local: path2.node.local.name,
+        imported
+      };
+    }
+  }
+}
+
+// src/utils/get-root-statement-path.ts
+var t4 = __toESM(require("@babel/types"), 1);
+function getRootStatementPath(path2) {
+  let current = path2.parentPath;
+  while (current) {
+    const next = current.parentPath;
+    if (next && t4.isProgram(next.node)) {
+      return current;
+    }
+    current = next;
+  }
+  return path2;
+}
+
+// src/split.ts
+function moduleDefinitionToImportSpecifier(definition) {
+  switch (definition.kind) {
+    case "default":
+      return t5.importDefaultSpecifier(t5.identifier(definition.local));
+    case "named":
+      return t5.importSpecifier(
+        t5.identifier(definition.local),
+        definition.imported ? t5.identifier(definition.imported) : t5.identifier(definition.local)
+      );
+    case "namespace":
+      return t5.importNamespaceSpecifier(t5.identifier(definition.local));
+  }
+}
+function moduleDefinitionToImportDeclaration(definition) {
+  return t5.importDeclaration(
+    [moduleDefinitionToImportSpecifier(definition)],
+    t5.stringLiteral(definition.source)
+  );
+}
+function moduleDefinitionsToImportDeclarations(definitions) {
+  const declarations = [];
+  for (let i = 0, len = definitions.length; i < len; i++) {
+    declarations[i] = moduleDefinitionToImportDeclaration(definitions[i]);
+  }
+  return declarations;
+}
+function isMutation(kind) {
+  switch (kind) {
+    case "let":
+    case "var":
+    case "param":
+      return true;
+    case "const":
+    case "hoisted":
+    case "local":
+    case "module":
+    case "unknown":
+      return false;
+  }
+}
+function registerModuleLevelBinding(ctx, modules, binding, target) {
+  const current = ctx.bindings.get(binding);
+  if (current) {
+    modules.push(current);
+  } else if (isPathValid(target.path, t5.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, t5.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);
+    }
+  } 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;
+    }
+    if (blockParent === programParent) {
+      registerModuleLevelBinding(ctx, modules, binding, target);
+    } else if (!pure) {
+      locals.push(target.identifier);
+      if (isMutation(target.kind)) {
+        mutations.push(target.identifier);
+      }
+    }
+  }
+}
+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);
+    }
+  }
+  return {
+    modules,
+    locals,
+    mutations
+  };
+}
+function createVirtualFileName(ctx) {
+  return `./${ctx.path.base}?${ctx.options.key}=${ctx.virtual.count++}${ctx.path.ext}`;
+}
+function createRootFile(ctx, bindings, replacement) {
+  const rootFile = createVirtualFileName(ctx);
+  const rootContent = generateCode(
+    ctx.id,
+    t5.program([
+      ...ctx.options.mode === "server" ? moduleDefinitionsToImportDeclarations(bindings.modules) : [],
+      t5.exportDefaultDeclaration(replacement)
+    ])
+  );
+  ctx.onVirtualFile(
+    rootFile,
+    { code: rootContent.code, map: rootContent.map },
+    "root"
+  );
+  return rootFile;
+}
+function createEntryFile(ctx, path2, rootFile, imported) {
+  let id = `${ctx.blocks.hash}-${ctx.blocks.count++}`;
+  if (ctx.options.env !== "production") {
+    id += `-${getDescriptiveName(path2, "anonymous")}`;
+  }
+  const entryID = path2.scope.generateUidIdentifier("entry");
+  const entryImports = [
+    {
+      kind: imported.kind,
+      source: imported.source,
+      local: entryID.name,
+      imported: imported.kind === "named" ? imported.name : void 0
+    }
+  ];
+  const args = [t5.stringLiteral(id)];
+  if (ctx.options.mode === "server") {
+    const rootID = path2.scope.generateUidIdentifier("root");
+    entryImports.push({
+      kind: "default",
+      source: rootFile,
+      local: rootID.name
+    });
+    args.push(rootID);
+  }
+  const entryFile = createVirtualFileName(ctx);
+  const entryContent = generateCode(
+    ctx.id,
+    t5.program([
+      ...moduleDefinitionsToImportDeclarations(entryImports),
+      t5.exportDefaultDeclaration(t5.callExpression(entryID, args))
+    ])
+  );
+  ctx.onVirtualFile(
+    entryFile,
+    { code: entryContent.code, map: entryContent.map },
+    "entry"
+  );
+  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,
+    t5.program([
+      ...moduleDefinitionsToImportDeclarations(modules),
+      t5.exportNamedDeclaration(path2.node)
+    ])
+  );
+  ctx.onVirtualFile(file, { code: compiled.code, map: compiled.map }, "none");
+  const statement = getRootStatementPath(path2);
+  const identifier2 = path2.node.id || path2.scope.generateUidIdentifier("func");
+  const definition = {
+    kind: "named",
+    local: identifier2.name,
+    source: file
+  };
+  statement.insertBefore(moduleDefinitionToImportDeclaration(definition));
+  path2.remove();
+  return definition;
+}
+function splitVariableDeclarator(ctx, path2) {
+  const init = unwrapPath(path2.get("init"), t5.isExpression);
+  const modules = init ? extractBindings(
+    ctx,
+    path2,
+    getForeignBindings(
+      path2,
+      isPathValid(init, t5.isArrowFunctionExpression) || isPathValid(init, t5.isFunctionExpression) ? "function" : "expression"
+    )
+  ).modules : [];
+  const file = createVirtualFileName(ctx);
+  const parent = path2.parentPath.node;
+  const compiled = generateCode(
+    ctx.id,
+    t5.program([
+      ...moduleDefinitionsToImportDeclarations(modules),
+      t5.exportNamedDeclaration(t5.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 = 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 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 ? path2.scope.generateUidIdentifier("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(t5.stringLiteral(targetName));
+        } else {
+          replacement.push(t5.nullLiteral());
+        }
+        if (applyMutations) {
+          replacement.push(t5.callExpression(applyMutations, []));
+        }
+        child.replaceWith(t5.returnStatement(t5.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(t5.stringLiteral(targetName));
+        } else {
+          replacement.push(t5.nullLiteral());
+        }
+        if (applyMutations) {
+          replacement.push(t5.callExpression(applyMutations, []));
+        }
+        child.replaceWith(t5.returnStatement(t5.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(
+          t5.arrayExpression([
+            RETURN_KEY,
+            arg.node ? arg.node : t5.nullLiteral(),
+            applyMutations ? t5.callExpression(applyMutations, []) : t5.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(
+            t5.arrayExpression([
+              YIELD_KEY,
+              arg.node ? arg.node : t5.nullLiteral(),
+              applyMutations ? t5.callExpression(applyMutations, []) : t5.nullLiteral()
+            ])
+          );
+        }
+      }
+    }
+  });
+  const error = path2.scope.generateUidIdentifier("error");
+  const throwResult = [THROW_KEY, error];
+  const haltResult = [NO_HALT_KEY];
+  if (applyMutations) {
+    throwResult.push(t5.callExpression(applyMutations, []));
+    haltResult.push(t5.nullLiteral());
+    haltResult.push(t5.callExpression(applyMutations, []));
+  }
+  const statements = [
+    t5.tryStatement(
+      t5.blockStatement(path2.node.body),
+      t5.catchClause(
+        error,
+        t5.blockStatement([t5.returnStatement(t5.arrayExpression(throwResult))])
+      )
+    ),
+    t5.returnStatement(t5.arrayExpression(haltResult))
+  ];
+  if (applyMutations) {
+    statements.unshift(
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          applyMutations,
+          t5.arrowFunctionExpression(
+            [],
+            t5.objectExpression(
+              mutations.map((item) => t5.objectProperty(item, item, false, true))
+            )
+          )
+        )
+      ])
+    );
+  }
+  path2.node.body = statements;
+  return { breaks, continues, hasReturn, hasYield, breakCount, continueCount };
+}
+function getBreakCheck(returnType, returnResult, breakCount, breaks, check) {
+  let current;
+  if (breakCount !== breaks.length) {
+    current = t5.blockStatement([t5.breakStatement()]);
+  }
+  for (let i = 0, len = breaks.length; i < len; i++) {
+    const target = breaks[i];
+    current = t5.blockStatement([
+      t5.ifStatement(
+        t5.binaryExpression("===", returnResult, t5.stringLiteral(target)),
+        t5.blockStatement([t5.breakStatement(t5.identifier(target))]),
+        current
+      )
+    ]);
+  }
+  if (current) {
+    return t5.ifStatement(
+      t5.binaryExpression("===", returnType, BREAK_KEY),
+      current,
+      check
+    );
+  }
+  return check;
+}
+function getContinueCheck(returnType, returnResult, continueCount, continues, check) {
+  let current;
+  if (continueCount !== continues.length) {
+    current = t5.blockStatement([t5.continueStatement()]);
+  }
+  for (let i = 0, len = continues.length; i < len; i++) {
+    const target = continues[i];
+    current = t5.blockStatement([
+      t5.ifStatement(
+        t5.binaryExpression("===", returnResult, t5.stringLiteral(target)),
+        t5.blockStatement([t5.continueStatement(t5.identifier(target))]),
+        current
+      )
+    ]);
+  }
+  if (current) {
+    return t5.ifStatement(
+      t5.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 = [
+    t5.variableDeclaration("let", [
+      t5.variableDeclarator(step),
+      // First, get the iterator by calling the generator
+      t5.variableDeclarator(
+        iterator,
+        t5.awaitExpression(t5.callExpression(registerID, args))
+      )
+    ]),
+    // Create a while statement, the intent is to
+    // repeatedly iterate the generator
+    t5.whileStatement(
+      t5.booleanLiteral(true),
+      t5.blockStatement([
+        // Get the next value
+        t5.expressionStatement(
+          t5.assignmentExpression(
+            "=",
+            step,
+            t5.awaitExpression(
+              t5.callExpression(
+                t5.memberExpression(iterator, t5.identifier("next")),
+                []
+              )
+            )
+          )
+        ),
+        // Check if the step is done
+        t5.ifStatement(
+          t5.memberExpression(step, t5.identifier("done")),
+          t5.blockStatement([
+            // exit the loop
+            t5.breakStatement()
+          ]),
+          // Otherwise, yield the value
+          t5.blockStatement([
+            t5.expressionStatement(
+              t5.yieldExpression(
+                t5.memberExpression(step, t5.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");
+  let check;
+  if (halting.hasReturn) {
+    check = t5.ifStatement(
+      t5.binaryExpression("===", returnType, RETURN_KEY),
+      t5.blockStatement([t5.returnStatement(returnResult)]),
+      check
+    );
+  }
+  if (halting.breakCount > 0) {
+    check = getBreakCheck(
+      returnType,
+      returnResult,
+      halting.breakCount,
+      halting.breaks,
+      check
+    );
+  }
+  if (halting.continueCount > 0) {
+    check = getContinueCheck(
+      returnType,
+      returnResult,
+      halting.continueCount,
+      halting.continues,
+      check
+    );
+  }
+  const replacement = [];
+  if (halting.hasYield) {
+    const blockID = path2.scope.generateUidIdentifier("block");
+    replacement.push(
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          blockID,
+          t5.callExpression(getImportIdentifier(ctx, path2, HIDDEN_GENERATOR), [
+            t5.memberExpression(
+              t5.awaitExpression(t5.importExpression(t5.stringLiteral(entryFile))),
+              t5.identifier("default")
+            ),
+            bindings.mutations.length ? t5.arrowFunctionExpression(
+              [returnMutations],
+              t5.assignmentExpression(
+                "=",
+                t5.objectPattern(
+                  bindings.mutations.map(
+                    (item) => t5.objectProperty(item, item, false, true)
+                  )
+                ),
+                returnMutations
+              )
+            ) : t5.nullLiteral()
+          ])
+        )
+      ])
+    );
+    const [reps, step] = getGeneratorReplacementForServerBlock(
+      path2,
+      blockID,
+      bindings.locals
+    );
+    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, path2, HIDDEN_FUNC), [
+                t5.memberExpression(
+                  t5.awaitExpression(
+                    t5.importExpression(t5.stringLiteral(entryFile))
+                  ),
+                  t5.identifier("default")
+                ),
+                bindings.mutations.length ? t5.arrowFunctionExpression(
+                  [returnMutations],
+                  t5.assignmentExpression(
+                    "=",
+                    t5.objectPattern(
+                      bindings.mutations.map(
+                        (item) => t5.objectProperty(item, item, false, true)
+                      )
+                    ),
+                    returnMutations
+                  )
+                ) : t5.nullLiteral()
+              ]),
+              bindings.locals
+            )
+          )
+        )
+      ])
+    );
+  }
+  if (check) {
+    replacement.push(check);
+  }
+  return t5.blockStatement(replacement);
+}
+function replaceBlock(ctx, path2, directive, bindings) {
+  const halting = transformBlockContent(path2, bindings.mutations);
+  const rootFile = createRootFile(
+    ctx,
+    bindings,
+    t5.functionExpression(
+      void 0,
+      bindings.locals,
+      t5.blockStatement(path2.node.body),
+      halting.hasYield,
+      true
+    )
+  );
+  const entryFile = createEntryFile(ctx, path2, rootFile, directive.target);
+  path2.replaceWith(
+    getBlockReplacement(ctx, path2, entryFile, bindings, halting)
+  );
+}
+function splitBlock(ctx, path2, directive) {
+  replaceBlock(
+    ctx,
+    path2,
+    directive,
+    extractBindings(
+      ctx,
+      path2,
+      getForeignBindings(path2, "block"),
+      directive.pure
+    )
+  );
+}
+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;
+  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(t5.nullLiteral());
+        }
+        if (applyMutations) {
+          replacement.push(t5.callExpression(applyMutations, []));
+        }
+        child.replaceWith(t5.returnStatement(t5.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 throwResult = [THROW_KEY, error];
+  const haltResult = [NO_HALT_KEY];
+  if (applyMutations) {
+    throwResult.push(t5.callExpression(applyMutations, []));
+    haltResult.push(t5.nullLiteral());
+    haltResult.push(t5.callExpression(applyMutations, []));
+  }
+  const statements = [
+    t5.tryStatement(
+      t5.blockStatement(path2.node.body),
+      t5.catchClause(
+        error,
+        t5.blockStatement([t5.returnStatement(t5.arrayExpression(throwResult))])
+      )
+    ),
+    t5.returnStatement(t5.arrayExpression(haltResult))
+  ];
+  if (applyMutations) {
+    statements.unshift(
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          applyMutations,
+          t5.arrowFunctionExpression(
+            [],
+            t5.objectExpression(
+              mutations.map((item) => t5.objectProperty(item, item, false, true))
+            )
+          )
+        )
+      ])
+    );
+  }
+  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");
+  const replacement = [];
+  if (halting.hasYield) {
+    const funcID = path2.scope.generateUidIdentifier("fn");
+    replacement.push(
+      t5.variableDeclaration("const", [
+        t5.variableDeclarator(
+          funcID,
+          t5.callExpression(getImportIdentifier(ctx, path2, HIDDEN_GENERATOR), [
+            t5.memberExpression(
+              t5.awaitExpression(t5.importExpression(t5.stringLiteral(entryFile))),
+              t5.identifier("default")
+            ),
+            bindings.mutations.length ? t5.arrowFunctionExpression(
+              [returnMutations],
+              t5.assignmentExpression(
+                "=",
+                t5.objectPattern(
+                  bindings.mutations.map(
+                    (item) => t5.objectProperty(item, item, false, true)
+                  )
+                ),
+                returnMutations
+              )
+            ) : t5.nullLiteral()
+          ])
+        )
+      ])
+    );
+    const [reps, step] = getGeneratorReplacementForServerBlock(path2, funcID, [
+      t5.arrayExpression(bindings.locals),
+      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, path2, HIDDEN_FUNC), [
+                t5.memberExpression(
+                  t5.awaitExpression(
+                    t5.importExpression(t5.stringLiteral(entryFile))
+                  ),
+                  t5.identifier("default")
+                ),
+                bindings.mutations.length ? t5.arrowFunctionExpression(
+                  [returnMutations],
+                  t5.assignmentExpression(
+                    "=",
+                    t5.objectPattern(
+                      bindings.mutations.map(
+                        (item) => t5.objectProperty(item, item, false, true)
+                      )
+                    ),
+                    returnMutations
+                  )
+                ) : t5.nullLiteral()
+              ]),
+              [t5.arrayExpression(bindings.locals), t5.spreadElement(rest)]
+            )
+          )
+        )
+      ])
+    );
+  }
+  replacement.push(t5.returnStatement(returnResult));
+  if (isPathValid(path2, t5.isFunctionExpression)) {
+    return t5.functionExpression(
+      path2.node.id,
+      [t5.restElement(rest)],
+      t5.blockStatement(replacement),
+      true,
+      halting.hasYield
+    );
+  }
+  return t5.arrowFunctionExpression(
+    [t5.restElement(rest)],
+    t5.blockStatement(replacement),
+    true
+  );
+}
+function replaceFunction(ctx, path2, func, bindings) {
+  const body = path2.get("body");
+  if (isPathValid(body, t5.isExpression)) {
+    body.replaceWith(t5.blockStatement([t5.returnStatement(body.node)]));
+  }
+  assert(isPathValid(body, t5.isBlockStatement), "invariant");
+  const halting = transformFunctionContent(body, bindings.mutations);
+  const rootFile = createRootFile(
+    ctx,
+    bindings,
+    t5.isFunctionExpression(path2.node) ? t5.functionExpression(
+      path2.node.id,
+      [t5.arrayPattern(bindings.locals), ...path2.node.params],
+      path2.node.body,
+      path2.node.async,
+      path2.node.generator
+    ) : t5.arrowFunctionExpression(
+      [t5.arrayPattern(bindings.locals), ...path2.node.params],
+      path2.node.body,
+      path2.node.async
+    )
+  );
+  const entryFile = createEntryFile(ctx, path2, rootFile, func.target);
+  return getFunctionReplacement(ctx, path2, entryFile, bindings, halting);
+}
+function splitFunction(ctx, path2, func) {
+  return replaceFunction(
+    ctx,
+    path2,
+    func,
+    extractBindings(ctx, path2, getForeignBindings(path2, "function"), func.pure)
+  );
+}
+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 t5.arrowFunctionExpression(
+    [t5.restElement(rest)],
+    t5.callExpression(
+      t5.memberExpression(
+        t5.awaitExpression(t5.importExpression(t5.stringLiteral(entryFile))),
+        t5.identifier("default")
+      ),
+      [t5.spreadElement(rest)]
+    ),
+    true
+  );
+}
+function splitExpression(ctx, path2, func) {
+  return replaceExpression(
+    ctx,
+    path2,
+    func,
+    extractBindings(
+      ctx,
+      path2,
+      getForeignBindings(path2, "expression"),
+      func.pure
+    )
+  );
+}
+
+// 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 t6 = __toESM(require("@babel/types"), 1);
+function getFunctionDefinitionFromPropName(definitions, propName) {
+  for (let i = 0, len = definitions.length; i < len; i++) {
+    const def = definitions[i];
+    if (def.source.kind === "default" && propName === "default") {
+      return def;
+    }
+    if (def.source.kind === "named" && propName === def.source.name) {
+      return def;
+    }
+  }
+  return void 0;
+}
+function getFunctionDefinitionFromCallee(ctx, path2) {
+  const callee = path2.node.callee;
+  const id = unwrapNode(callee, t6.isIdentifier);
+  if (id) {
+    const binding = path2.scope.getBindingIdentifier(id.name);
+    if (binding) {
+      return ctx.registrations.identifiers.get(binding);
+    }
+    return void 0;
+  }
+  const memberExpr = unwrapNode(callee, t6.isMemberExpression);
+  if (memberExpr && !memberExpr.computed && t6.isIdentifier(memberExpr.property)) {
+    const object = unwrapNode(memberExpr.object, t6.isIdentifier);
+    if (object) {
+      const binding = path2.scope.getBindingIdentifier(object.name);
+      if (binding) {
+        const definitions = ctx.registrations.namespaces.get(binding);
+        if (definitions) {
+          return getFunctionDefinitionFromPropName(
+            definitions,
+            memberExpr.property.name
+          );
+        }
+      }
+    }
+  }
+  return void 0;
+}
+function isValidFunction(node) {
+  return t6.isArrowFunctionExpression(node) || t6.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) {
+    return;
+  }
+  const args = path2.get("arguments");
+  const expr = args[0];
+  if (isPathValid(expr, t6.isExpression)) {
+    if (isSkippableFunction(expr.node)) {
+      return;
+    }
+    const replacement = isPathValid(expr, isValidFunction) ? splitFunction(ctx, expr, definition) : splitExpression(ctx, expr, definition);
+    if (definition.preserve) {
+      expr.replaceWith(t6.addComment(replacement, "leading", "@dismantle skip"));
+    } else {
+      path2.replaceWith(replacement);
+    }
+  }
+}
+
+// src/utils/register-import-specifiers.ts
+var t7 = __toESM(require("@babel/types"), 1);
+function registerImportSpecifier(ctx, node, definition) {
+  if (t7.isImportSpecifier(node)) {
+    if (node.importKind === "type" || node.importKind === "typeof") {
+      return;
+    }
+    const key = getImportSpecifierName(node);
+    if (definition.source.kind === "named" && key === definition.source.name || definition.source.kind === "default" && key === "default") {
+      ctx.registrations.identifiers.set(node.local, definition);
+    }
+  }
+  if (t7.isImportDefaultSpecifier(node) && definition.source.kind === "default") {
+    ctx.registrations.identifiers.set(node.local, definition);
+  }
+  if (t7.isImportNamespaceSpecifier(node)) {
+    let current = ctx.registrations.namespaces.get(node.local);
+    if (!current) {
+      current = [];
+    }
+    current.push(definition);
+    ctx.registrations.namespaces.set(node.local, current);
+  }
+}
+function registerImportDeclarationByDefinition(ctx, path2, definition) {
+  for (let i = 0, len = path2.node.specifiers.length; i < len; i++) {
+    const specifier = path2.node.specifiers[i];
+    registerImportSpecifier(ctx, specifier, definition);
+  }
+}
+function registerImportSpecifiers(ctx, programPath) {
+  const len = ctx.options.functions.length;
+  if (!len) {
+    return;
+  }
+  programPath.traverse({
+    ImportDeclaration(path2) {
+      if (path2.node.importKind === "type" || path2.node.importKind === "typeof") {
+        return;
+      }
+      for (let i = 0; i < len; i++) {
+        const func = ctx.options.functions[i];
+        if (func.source.source === path2.node.source.value) {
+          registerImportDeclarationByDefinition(ctx, path2, func);
+        }
+      }
+    }
+  });
+}
+
+// src/plugin.ts
+function plugin() {
+  return {
+    name: "dismantle",
+    visitor: {
+      Program(path2, ctx) {
+        registerImportSpecifiers(ctx.opts, path2);
+      },
+      BlockStatement(path2, ctx) {
+        transformBlock(ctx.opts, path2);
+      },
+      CallExpression(path2, ctx) {
+        transformCall(ctx.opts, path2);
+      }
+    }
+  };
+}
+
+// src/utils/xxhash32.ts
+var PRIME32_1 = 2654435761;
+var PRIME32_2 = 2246822519;
+var PRIME32_3 = 3266489917;
+var PRIME32_4 = 668265263;
+var PRIME32_5 = 374761393;
+function toUtf8(text) {
+  const bytes = [];
+  for (let i = 0, n = text.length; i < n; ++i) {
+    const c = text.charCodeAt(i);
+    if (c < 128) {
+      bytes.push(c);
+    } else if (c < 2048) {
+      bytes.push(192 | c >> 6, 128 | c & 63);
+    } else if (c < 55296 || c >= 57344) {
+      bytes.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+    } else {
+      const cp = 65536 + ((c & 1023) << 10 | text.charCodeAt(++i) & 1023);
+      bytes.push(
+        240 | cp >> 18 & 7,
+        128 | cp >> 12 & 63,
+        128 | cp >> 6 & 63,
+        128 | cp & 63
+      );
+    }
+  }
+  return new Uint8Array(bytes);
+}
+function xxHash32(buffer, seed = 0) {
+  buffer = typeof buffer === "string" ? toUtf8(buffer) : buffer;
+  const b = buffer;
+  let acc = seed + PRIME32_5 & 4294967295;
+  let offset = 0;
+  if (b.length >= 16) {
+    const accN = [
+      seed + PRIME32_1 + PRIME32_2 & 4294967295,
+      seed + PRIME32_2 & 4294967295,
+      seed + 0 & 4294967295,
+      seed - PRIME32_1 & 4294967295
+    ];
+    const b2 = buffer;
+    const limit2 = b2.length - 16;
+    let lane = 0;
+    for (offset = 0; (offset & 4294967280) <= limit2; offset += 4) {
+      const i = offset;
+      const laneN0 = b2[i + 0] + (b2[i + 1] << 8);
+      const laneN1 = b2[i + 2] + (b2[i + 3] << 8);
+      const laneNP = laneN0 * PRIME32_2 + (laneN1 * PRIME32_2 << 16);
+      let acc2 = accN[lane] + laneNP & 4294967295;
+      acc2 = acc2 << 13 | acc2 >>> 19;
+      const acc0 = acc2 & 65535;
+      const acc1 = acc2 >>> 16;
+      accN[lane] = acc0 * PRIME32_1 + (acc1 * PRIME32_1 << 16) & 4294967295;
+      lane = lane + 1 & 3;
+    }
+    acc = (accN[0] << 1 | accN[0] >>> 31) + (accN[1] << 7 | accN[1] >>> 25) + (accN[2] << 12 | accN[2] >>> 20) + (accN[3] << 18 | accN[3] >>> 14) & 4294967295;
+  }
+  acc = acc + buffer.length & 4294967295;
+  const limit = buffer.length - 4;
+  for (; offset <= limit; offset += 4) {
+    const i = offset;
+    const laneN0 = b[i + 0] + (b[i + 1] << 8);
+    const laneN1 = b[i + 2] + (b[i + 3] << 8);
+    const laneP = laneN0 * PRIME32_3 + (laneN1 * PRIME32_3 << 16);
+    acc = acc + laneP & 4294967295;
+    acc = acc << 17 | acc >>> 15;
+    acc = (acc & 65535) * PRIME32_4 + ((acc >>> 16) * PRIME32_4 << 16) & 4294967295;
+  }
+  for (; offset < b.length; ++offset) {
+    const lane = b[offset];
+    acc += lane * PRIME32_5;
+    acc = acc << 11 | acc >>> 21;
+    acc = (acc & 65535) * PRIME32_1 + ((acc >>> 16) * PRIME32_1 << 16) & 4294967295;
+  }
+  acc ^= acc >>> 15;
+  acc = ((acc & 65535) * PRIME32_2 & 4294967295) + ((acc >>> 16) * PRIME32_2 << 16);
+  acc ^= acc >>> 13;
+  acc = ((acc & 65535) * PRIME32_3 & 4294967295) + ((acc >>> 16) * PRIME32_3 << 16);
+  acc ^= acc >>> 16;
+  return acc < 0 ? acc + 4294967296 : acc;
+}
+
+// src/index.ts
+async function compile(id, code, options) {
+  const parsedPath = import_node_path.default.parse(id);
+  const entries = [];
+  const roots = [];
+  const files = /* @__PURE__ */ new Map();
+  const ctx = {
+    id,
+    path: parsedPath,
+    imports: /* @__PURE__ */ new Map(),
+    virtual: {
+      count: 0
+    },
+    options,
+    bindings: /* @__PURE__ */ new Map(),
+    blocks: {
+      hash: xxHash32(id).toString(16),
+      count: 0
+    },
+    onVirtualFile(current, content, mode) {
+      const filePath = import_node_path.default.join(parsedPath.dir, current);
+      files.set(import_node_path.default.join(parsedPath.dir, current), content);
+      if (mode === "entry") {
+        entries.push(filePath);
+      } else if (mode === "root") {
+        roots.push(filePath);
+      }
+    },
+    registrations: {
+      identifiers: /* @__PURE__ */ new Map(),
+      namespaces: /* @__PURE__ */ new Map()
+    }
+  };
+  const plugins = ["jsx"];
+  if (/\.[mc]?tsx?$/i.test(id)) {
+    plugins.push("typescript");
+  }
+  const result = await babel.transformAsync(code, {
+    plugins: [[plugin, ctx]],
+    parserOpts: {
+      plugins
+    },
+    filename: parsedPath.base,
+    ast: false,
+    sourceFileName: id,
+    sourceMaps: true,
+    configFile: false,
+    babelrc: false
+  });
+  assert(result, "invariant");
+  return {
+    code: result.code,
+    map: result.map,
+    files,
+    entries,
+    roots
+  };
+}
+//# sourceMappingURL=index.cjs.map