@fluixi/compiler 1.0.0-alpha.100

package/dist/transform/intrinsics.mjs

@@ -0,0 +1,238 @@
+// src/analyze/intrinsics.ts
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
+  $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
+  $cachedResource: { export: "cachedResource", module: "@fluixi/reactive/cached-resource", returns: "resource-handle" },
+  // No short runtime form for these yet, so the intrinsic stands for the `create*`
+  // name. Still worth having: no import to write, and when a shorter form is
+  // designed, the change is this line rather than a compiler pass.
+  $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  // Not value constructors, but the compiler has to know them: they change what a read
+  // does. `untrack` suppresses dependency collection, which is exactly the kind of thing
+  // dependency analysis must not guess at.
+  $untrack: { export: "untrack", module: REACTIVE_MODULE, returns: "plain" },
+  $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" },
+  // Scopes, scheduling and lifecycle: no value to classify, but the same authoring promise,
+  // no import to write. `$cleanup` registers a callback on the current owner (`onCleanup`).
+  $batch: { export: "batch", module: REACTIVE_MODULE, returns: "plain" },
+  $cleanup: { export: "onCleanup", module: REACTIVE_MODULE, returns: "plain" },
+  $root: { export: "root", module: REACTIVE_MODULE, returns: "plain" },
+  $context: { export: "context", module: REACTIVE_MODULE, returns: "plain" },
+  $renderEffect: { export: "renderEffect", module: REACTIVE_MODULE, returns: "effect" },
+  $computed: { export: "computed", module: REACTIVE_MODULE, returns: "effect" },
+  // Storage for where the code runs, and a signal kept in it. `$persisted` is a signal
+  // handle as far as reads go: the same accessor with `set` on it.
+  $storage: { export: "useStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $asyncStorage: { export: "useAsyncStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $persisted: { export: "persisted", module: "@fluixi/core/storage", returns: "signal-handle" },
+  // An environment variable, public or server-only; the browser build refuses a secret.
+  $env: { export: "env", module: "@fluixi/start/env", returns: "plain" }
+};
+var RUNTIME_PRIMITIVES = {
+  signal: "signal-handle",
+  memo: "memo-handle",
+  effect: "effect",
+  store: "store-handle",
+  createSignal: ["signal-accessor", "signal-setter"],
+  createMemo: "memo-accessor",
+  createEffect: "effect",
+  createRenderEffect: "effect",
+  renderEffect: "effect",
+  computed: "effect",
+  createStore: "reactive-object",
+  resource: "resource-handle",
+  cachedResource: "resource-handle",
+  createResource: "reactive-object",
+  createSelector: "memo-accessor",
+  createDeferred: "memo-accessor"
+};
+var PRIMITIVE_MODULES = [
+  "@fluixi/reactive",
+  "@fluixi/reactive/signal",
+  "@fluixi/reactive/store",
+  "@fluixi/reactive/cached-resource",
+  "@fluixi/core"
+];
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+function isIntrinsicName(name) {
+  return Object.prototype.hasOwnProperty.call(INTRINSICS, name);
+}
+function isPrimitiveModule(source) {
+  return PRIMITIVE_MODULES.includes(source);
+}
+
+// src/analyze/reactive-bindings.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties ?? []) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements ?? []) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) for (const item of value) walk(item, visit);
+    else if (value && typeof value === "object") walk(value, visit);
+  }
+}
+function calledPrimitive(node, bindings) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  const name = callee.name;
+  const imported = bindings.primitives.get(name);
+  if (imported) return imported;
+  const intrinsic = INTRINSICS[name];
+  if (intrinsic && !bindings.shadowed.has(name)) return intrinsic.returns;
+  return void 0;
+}
+function classify(id, returns, kinds) {
+  if (Array.isArray(returns)) {
+    if (id.type === "ArrayPattern") {
+      id.elements.forEach((element, index) => {
+        const kind = returns[index];
+        if (element?.type === "Identifier" && kind) kinds.set(element.name, kind);
+      });
+    }
+    return;
+  }
+  if (id.type === "Identifier") kinds.set(id.name, returns);
+}
+function resolveReactiveBindings(program) {
+  const bindings = { kinds: /* @__PURE__ */ new Map(), primitives: /* @__PURE__ */ new Map(), shadowed: /* @__PURE__ */ new Set() };
+  const root = program;
+  walk(root, (node) => {
+    const names = /* @__PURE__ */ new Set();
+    if (node.type === "VariableDeclarator") patternNames(node.id, names);
+    else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") patternNames(node.id, names);
+    else if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") patternNames(node.local, names);
+    else if (node.type === "ImportSpecifier") patternNames(node.local, names);
+    else if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration") {
+      for (const p of node.params ?? []) patternNames(p, names);
+    }
+    for (const name of names) if (INTRINSICS[name]) bindings.shadowed.add(name);
+  });
+  for (const statement of root.body ?? []) {
+    if (statement.type !== "ImportDeclaration") continue;
+    if (!isPrimitiveModule(statement.source?.value)) continue;
+    for (const specifier of statement.specifiers ?? []) {
+      if (specifier.type !== "ImportSpecifier") continue;
+      const importedNode = specifier.imported;
+      const imported = importedNode.type === "Identifier" ? importedNode.name : importedNode.value;
+      const returns = RUNTIME_PRIMITIVES[imported];
+      if (returns) bindings.primitives.set(specifier.local.name, returns);
+    }
+  }
+  walk(root, (node) => {
+    if (node.type !== "VariableDeclarator" || !node.init) return;
+    const returns = calledPrimitive(node.init, bindings);
+    if (returns) classify(node.id, returns, bindings.kinds);
+  });
+  return bindings;
+}
+
+// src/transform/intrinsics.ts
+function walk2(root, visit) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) for (const item of value) walk2(item, visit);
+    else if (value && typeof value === "object") walk2(value, visit);
+  }
+}
+function collectIntrinsicEdits(program) {
+  const edits = [];
+  const diagnostics = [];
+  const imports = /* @__PURE__ */ new Map();
+  const reported = /* @__PURE__ */ new Set();
+  const { shadowed } = resolveReactiveBindings(program);
+  walk2(program, (node) => {
+    if (node.type !== "CallExpression") return;
+    const callee = node.callee;
+    if (callee?.type !== "Identifier") return;
+    const name = callee.name;
+    if (!isIntrinsicName(name)) return;
+    if (shadowed.has(name)) {
+      if (!reported.has(name)) {
+        reported.add(name);
+        diagnostics.push({
+          name,
+          message: `${name} is reserved for the compiler, and this module binds it. The call keeps your binding's meaning; rename it to use the intrinsic.`,
+          start: callee.start
+        });
+      }
+      return;
+    }
+    const intrinsic = INTRINSICS[name];
+    edits.push({ start: callee.start, end: callee.end, code: intrinsic.export });
+    const forModule = imports.get(intrinsic.module) ?? /* @__PURE__ */ new Set();
+    forModule.add(intrinsic.export);
+    imports.set(intrinsic.module, forModule);
+  });
+  return { edits, diagnostics, imports };
+}
+function avoidBindingClashes(program, result, bound) {
+  const importedAsIs = /* @__PURE__ */ new Set();
+  for (const stmt of program.body ?? []) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    const module = stmt.source.value;
+    for (const spec of stmt.specifiers ?? []) {
+      if (spec.type !== "ImportSpecifier") continue;
+      const imported = spec.imported.name ?? spec.imported.value;
+      if (imported === spec.local.name && result.imports.get(module)?.has(imported)) {
+        importedAsIs.add(imported);
+      }
+    }
+  }
+  const aliases = /* @__PURE__ */ new Map();
+  for (const names of result.imports.values()) {
+    for (const name of names) if (bound.has(name) && !importedAsIs.has(name)) aliases.set(name, `__fx_${name}`);
+  }
+  if (!aliases.size) return;
+  for (const edit of result.edits) {
+    const alias = aliases.get(edit.code);
+    if (alias) edit.code = alias;
+  }
+  result.aliases = aliases;
+}
+function intrinsicImports(result, bound) {
+  const lines = [];
+  for (const [module, names] of [...result.imports].sort(([a], [b]) => a.localeCompare(b))) {
+    const wanted = [...names].filter((name) => result.aliases?.has(name) || !bound.has(name)).sort().map((name) => result.aliases?.has(name) ? `${name} as ${result.aliases.get(name)}` : name);
+    if (wanted.length) lines.push(`import { ${wanted.join(", ")} } from ${JSON.stringify(module)};`);
+  }
+  return lines.length ? `${lines.join("\n")}
+` : "";
+}
+export {
+  avoidBindingClashes,
+  collectIntrinsicEdits,
+  intrinsicImports
+};

package/dist/transform/props.cjs

@@ -0,0 +1,441 @@
+"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/transform/props.ts
+var props_exports = {};
+__export(props_exports, {
+  collectPropsEdits: () => collectPropsEdits,
+  transformProps: () => transformProps
+});
+module.exports = __toCommonJS(props_exports);
+var import_parser = require("@babel/parser");
+var import_magic_string = __toESM(require("magic-string"), 1);
+
+// src/analyze/props-destructure.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function isSafeDefault(node) {
+  switch (node.type) {
+    case "StringLiteral":
+    case "NumericLiteral":
+    case "BooleanLiteral":
+    case "NullLiteral":
+    case "BigIntLiteral":
+    case "RegExpLiteral":
+    case "Identifier":
+      return true;
+    // ESTree spells every literal as `Literal`; both shapes reach this analysis.
+    case "Literal":
+      return true;
+    case "TemplateLiteral":
+      return node.expressions.every(isSafeDefault);
+    case "UnaryExpression":
+      return isSafeDefault(node.argument);
+    case "MemberExpression":
+      return false;
+    default:
+      return false;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "range" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) if (item && typeof item === "object") walk(item, visit);
+    } else if (value && typeof value === "object" && typeof value.type === "string") {
+      walk(value, visit);
+    }
+  }
+}
+function reassignedNames(body) {
+  const written = /* @__PURE__ */ new Set();
+  walk(body, (node) => {
+    if (node.type === "AssignmentExpression") patternNames(node.left, written);
+    else if (node.type === "UpdateExpression") {
+      const arg = node.argument;
+      if (arg?.type === "Identifier") written.add(arg.name);
+    }
+  });
+  return written;
+}
+function shadowedNames(body, candidates) {
+  const shadowed = /* @__PURE__ */ new Set();
+  const note = (node) => {
+    const names = /* @__PURE__ */ new Set();
+    patternNames(node, names);
+    for (const n of names) if (candidates.has(n)) shadowed.add(n);
+  };
+  walk(body, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        note(node.id);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        note(node.id);
+        for (const p of node.params ?? []) note(p);
+        return;
+      case "CatchClause":
+        note(node.param);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        note(node.id);
+        return;
+    }
+  });
+  return shadowed;
+}
+function collect(pattern, path, plan) {
+  for (const property of pattern.properties ?? []) {
+    if (property.type === "RestElement") {
+      const argument = property.argument;
+      if (argument?.type !== "Identifier" || path.length > 0) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(argument, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "rest" });
+        continue;
+      }
+      plan.rest = { name: argument.name, keys: [] };
+      continue;
+    }
+    if (property.computed) {
+      const names2 = /* @__PURE__ */ new Set();
+      patternNames(property.value, names2);
+      for (const name of names2) plan.bails.push({ name, reason: "computed" });
+      continue;
+    }
+    const key = property.key;
+    const propertyName = key.type === "Identifier" ? key.name : key.value;
+    let value = property.value;
+    let fallback;
+    if (value.type === "AssignmentPattern") {
+      fallback = value.right;
+      value = value.left;
+    }
+    const here = [...path, propertyName];
+    if (value.type === "Identifier") {
+      if (fallback && !isSafeDefault(fallback)) {
+        plan.bails.push({ name: value.name, reason: "unsafe-default" });
+        continue;
+      }
+      plan.reads.push({ name: value.name, path: here, ...fallback ? { fallback } : {} });
+      continue;
+    }
+    if (value.type === "ObjectPattern") {
+      if (fallback) {
+        const names2 = /* @__PURE__ */ new Set();
+        patternNames(value, names2);
+        for (const name of names2) plan.bails.push({ name, reason: "unsafe-default" });
+        continue;
+      }
+      collect(value, here, plan);
+      continue;
+    }
+    const names = /* @__PURE__ */ new Set();
+    patternNames(value, names);
+    for (const name of names) plan.bails.push({ name, reason: "computed" });
+  }
+}
+function planPropsDestructure(pattern, body) {
+  const plan = { reads: [], bails: [] };
+  if (pattern?.type !== "ObjectPattern") return plan;
+  collect(pattern, [], plan);
+  if (plan.rest) {
+    if (body?.type !== "BlockStatement") {
+      plan.bails.push({ name: plan.rest.name, reason: "rest" });
+      delete plan.rest;
+    } else {
+      plan.rest.keys = (pattern.properties ?? []).filter((p) => p.type !== "RestElement" && !p.computed).map((p) => {
+        const key = p.key;
+        return key.type === "Identifier" ? key.name : key.value;
+      });
+    }
+  }
+  if (plan.reads.length === 0 && !plan.rest) return plan;
+  const candidates = new Set(plan.reads.map((r) => r.name));
+  if (plan.rest) candidates.add(plan.rest.name);
+  const written = reassignedNames(body);
+  const shadowed = shadowedNames(body, candidates);
+  const kept = [];
+  for (const read of plan.reads) {
+    if (written.has(read.name)) plan.bails.push({ name: read.name, reason: "reassigned" });
+    else if (shadowed.has(read.name)) plan.bails.push({ name: read.name, reason: "shadowed" });
+    else kept.push(read);
+  }
+  plan.reads = kept;
+  if (plan.rest && written.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "reassigned" });
+    delete plan.rest;
+  } else if (plan.rest && shadowed.has(plan.rest.name)) {
+    plan.bails.push({ name: plan.rest.name, reason: "shadowed" });
+    delete plan.rest;
+  }
+  return plan;
+}
+function explainBail(reason) {
+  switch (reason) {
+    case "rest":
+      return "this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";
+    case "computed":
+      return "the property is not known until it runs";
+    case "reassigned":
+      return "the binding is assigned to, and props are read-only";
+    case "shadowed":
+      return "an inner scope binds the same name";
+    case "unsafe-default":
+      return "the default would have to run again on every read";
+  }
+}
+
+// src/transform/bindings.ts
+function patternNames2(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames2(p.argument, out);
+        else patternNames2(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames2(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames2(node.left, out);
+      return;
+    case "RestElement":
+      patternNames2(node.argument, out);
+      return;
+  }
+}
+function declared(node, out) {
+  switch (node.type) {
+    case "ImportDeclaration":
+      for (const s of node.specifiers) patternNames2(s.local, out);
+      return;
+    case "VariableDeclaration":
+      for (const d of node.declarations) patternNames2(d.id, out);
+      return;
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+      patternNames2(node.id, out);
+      return;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration":
+      if (node.declaration) declared(node.declaration, out);
+      return;
+  }
+}
+function moduleBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) declared(statement, names);
+  return names;
+}
+
+// src/transform/props.ts
+function walk2(root, visit, parent = null) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  if (root.type.startsWith("TS")) return;
+  if (visit(root, parent) === false) return;
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) {
+      for (const item of value) walk2(item, visit, root);
+    } else if (value && typeof value === "object") {
+      walk2(value, visit, root);
+    }
+  }
+}
+function isComponentName(name) {
+  return !!name && name[0] >= "A" && name[0] <= "Z";
+}
+function componentFunctions(program) {
+  const found = [];
+  walk2(program, (node) => {
+    if (node.type === "FunctionDeclaration" && isComponentName(node.id?.name)) {
+      found.push(node);
+      return;
+    }
+    if (node.type === "VariableDeclarator" && isComponentName(node.id?.name)) {
+      const init = node.init;
+      if (init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression")) found.push(init);
+    }
+  });
+  return found;
+}
+function usedNames(fn) {
+  const names = /* @__PURE__ */ new Set();
+  walk2(fn, (node) => {
+    if (node.type === "Identifier") names.add(node.name);
+  });
+  return names;
+}
+function isReferencePosition(node, parent) {
+  if (!parent) return true;
+  switch (parent.type) {
+    case "MemberExpression":
+    case "OptionalMemberExpression":
+      return !(parent.property === node && !parent.computed);
+    case "ObjectProperty":
+    case "ObjectMethod":
+    case "ClassProperty":
+    case "ClassMethod":
+      return !(parent.key === node && !parent.computed);
+    case "LabeledStatement":
+    case "BreakStatement":
+    case "ContinueStatement":
+      return parent.label !== node;
+    case "ImportSpecifier":
+    case "ExportSpecifier":
+      return false;
+    default:
+      return true;
+  }
+}
+function collectPropsEdits(program, code, options = {}) {
+  const edits = [];
+  const diagnostics = [];
+  const used = /* @__PURE__ */ new Set();
+  for (const fn of componentFunctions(program)) {
+    const pattern = fn.params?.[0];
+    if (pattern?.type !== "ObjectPattern") continue;
+    const plan = planPropsDestructure(pattern, fn.body);
+    for (const b of plan.bails) {
+      diagnostics.push({ name: b.name, reason: b.reason, message: explainBail(b.reason), start: pattern.start });
+    }
+    if (plan.bails.length > 0) continue;
+    if (plan.reads.length === 0 && !plan.rest) continue;
+    const taken = usedNames(fn);
+    let parameter = options.parameterName ?? "props";
+    while (taken.has(parameter)) parameter = `_${parameter}`;
+    const replacement = /* @__PURE__ */ new Map();
+    for (const read of plan.reads) {
+      const access = `${parameter}.${read.path.join(".")}`;
+      const fallback = read.fallback;
+      replacement.set(
+        read.name,
+        fallback ? `(${access} === undefined ? ${code.slice(fallback.start, fallback.end)} : ${access})` : access
+      );
+    }
+    const annotation = pattern.typeAnnotation;
+    edits.push({ start: pattern.start, end: annotation?.start ?? pattern.end, code: parameter });
+    if (plan.rest) {
+      const keys = plan.rest.keys.map((k) => JSON.stringify(k)).join(", ");
+      const body = fn.body;
+      edits.push({
+        start: body.start + 1,
+        end: body.start + 1,
+        code: `
+  const [, ${plan.rest.name}] = splitProps(${parameter}, [${keys}]);`
+      });
+      used.add("splitProps");
+    }
+    const matches = [];
+    walk2(fn.body, (node, parent) => {
+      if (node.type !== "Identifier") return void 0;
+      const text = replacement.get(node.name);
+      if (!text) return void 0;
+      const shorthand = parent?.type === "ObjectProperty" && parent.shorthand && parent.value === node;
+      if (!shorthand && !isReferencePosition(node, parent)) return void 0;
+      const path = plan.reads.find((r) => r.name === node.name).path;
+      matches.push({ node, parent: shorthand ? parent : null, text, property: path[path.length - 1] });
+      return void 0;
+    });
+    for (const match of matches) {
+      if (match.parent) {
+        edits.push({ start: match.parent.start, end: match.parent.end, code: `${match.node.name}: ${match.text}` });
+      } else {
+        edits.push({ start: match.node.start, end: match.node.end, code: match.text });
+      }
+      asMemberRead(match.node, parameter, match.property);
+    }
+  }
+  return { edits, diagnostics, used };
+}
+function asMemberRead(node, parameter, property) {
+  node.type = "MemberExpression";
+  node.computed = false;
+  node.optional = false;
+  node.object = { type: "Identifier", name: parameter, start: node.start, end: node.start };
+  node.property = { type: "Identifier", name: property, start: node.end, end: node.end };
+  delete node["name"];
+}
+function transformProps(code, filename = "module.tsx", options = {}) {
+  const ast = (0, import_parser.parse)(code, {
+    sourceType: "module",
+    plugins: ["typescript", "jsx"],
+    errorRecovery: true
+  });
+  const { edits, diagnostics, used } = collectPropsEdits(ast.program, code, options);
+  const source = new import_magic_string.default(code);
+  for (const e of edits) {
+    if (e.start === e.end) source.appendLeft(e.start, e.code);
+    else source.overwrite(e.start, e.end, e.code);
+  }
+  if (used.has("splitProps") && !moduleBindings(ast.program).has("splitProps")) {
+    source.prepend(`import { splitProps } from ${JSON.stringify(options.runtimeModule ?? "@fluixi/dom")};
+`);
+  }
+  return {
+    code: source.toString(),
+    map: source.generateMap({ source: filename, includeContent: true, hires: true }),
+    diagnostics,
+    rewritten: edits.filter((e) => e.code !== (options.parameterName ?? "props")).length
+  };
+}