const input = `
function inlineMe() {
  let num = 3;
  beforeI;
  console.log("Hello from inside!", num);
  afterI;
}

function fn() {
  beforeF;
  inlineMe();
  afterF;
}

fn(1);
`.trim();

const res = babel.transformSync(input, {
  configFile: false,
  sourceMaps: true,
  plugins: [
    await load("plugin-experimental-source-map-scopes"),
    /**
     * @param {core.PluginAPI} param0
     * @return {core.PluginObject}
     */
    function ({ types: t }) {
      return {
        visitor: {
          FunctionDeclaration(path) {
            //path.scope.rename("param", "p1");
          },
          // Do some inlining
          CallExpression(path) {
            if (path.get("callee").isIdentifier({ name: "inlineMe" })) {
              /** @type {core.NodePath<core.types.FunctionDeclaration>} */
              const fn = path.scope.getBinding("inlineMe").path;

              const argsNames = [];
              const argsDecls = [];
              path.get("arguments").forEach((arg, i) => {
                arg.assertExpression();
                const tmpId = path.scope.generateUidIdentifierBasedOnNode(
                  arg.node,
                  `arg${i}`
                );
                //tmpId.loc = arg.node.loc;
                argsNames.push(tmpId.name);
                argsDecls.push(t.variableDeclarator(tmpId, arg.node));
              });

              fn.get("params").forEach((param, i) => {
                param.assertIdentifier();
                fn.scope.rename(param.node.name, argsNames[i]);
              });

              const fnBody = fn.node.body.body;

              const scopeInfo = this.file.opts.generatorOpts.getScopeInfo?.(
                fnBody[0]
              );
              if (scopeInfo) {
                scopeInfo.callsite = {
                  column: path.node.loc.start.column,
                  line: path.node.loc.start.line,
                  source: "unknown",
                };
                scopeInfo.isScope = false;
              }

              fn.remove();

              path.replaceWithMultiple(
                [
                  argsDecls.length > 0 &&
                    t.variableDeclaration("let", argsDecls),
                  ...fnBody,
                ].filter(Boolean)
              );
            }
          },
        },
      };
    },
  ],
  ast: true,
});