slidemind 0.3.20 → 0.4.1

package/src/lib/inline-components.mjs

@@ -0,0 +1,613 @@
+// Inline the local components a slide declares, so a reader that only knows
+// literal elements sees every element a component instance draws.
+//
+// A repeated organism is one local component and one call site per member
+// (workflow/authoring.md → Repeated organisms are components):
+//
+//   const Repeat1 = ({ x, y, id, textId, text }) => (<>
+//     <B id={id} x={x} y={y} w={248} h={112} />
+//     <T id={textId} x={x + 72} y={y + 16} w={160}>{text}</T>
+//   </>);
+//   <Repeat1 x={0} y={0} id="c1" textId="t1" text={<><P>Plan</P></>} />
+//
+// Readers of slide SOURCE — the preservation reader, the bounded repair —
+// address elements by literal ids and literal geometry. `inlineComponents`
+// rewrites each call site of a COMPOSITE component (its template calls other
+// components) into that template with the call site's literal props
+// substituted, and blanks the declaration once no call site is left. Leaf
+// helpers (`B`, `T`, …: only lowercase DOM inside) stay call sites: their
+// call-site attributes ARE the element, which is how every reader reads them.
+//
+// `preserveLines` (default true): an inlined call site keeps its line count
+// and a blanked declaration leaves empty lines, so a reported line still points
+// into the file the author wrote. `preserveLines: false` keeps the template's
+// own line breaks (one element per line, at the call site's indentation) — the
+// shape the bounded repair rewrites line by line.
+//
+// Pure and import-free: byte-mirrored into the add-in (edit-contracts group).
+
+// ---------------------------------------------------------------------------
+// A small JS/JSX scanner — enough to find where an expression, a parenthesised
+// body or an element ends without being fooled by quotes in JSX text.
+// ---------------------------------------------------------------------------
+
+/** End (exclusive) of the string, template literal or comment opening at `i`; `i` when none does. */
+function skipLiteral(src, i) {
+  const c = src[i];
+  if (c === "/" && src[i + 1] === "/") {
+    const nl = src.indexOf("\n", i);
+    return nl < 0 ? src.length : nl;
+  }
+  if (c === "/" && src[i + 1] === "*") {
+    const close = src.indexOf("*/", i + 2);
+    return close < 0 ? src.length : close + 2;
+  }
+  if (c === '"' || c === "'") {
+    for (let k = i + 1; k < src.length; k++) {
+      if (src[k] === "\\") k++;
+      else if (src[k] === c) return k + 1;
+      else if (src[k] === "\n") return i + 1; // never closed: one character
+    }
+    return i + 1;
+  }
+  if (c === "`") {
+    for (let k = i + 1; k < src.length; k++) {
+      if (src[k] === "\\") k++;
+      else if (src[k] === "`") return k + 1;
+      else if (src[k] === "$" && src[k + 1] === "{") k = scanBalanced(src, k + 1, "{", "}") - 1;
+    }
+    return src.length;
+  }
+  return i;
+}
+
+/** Does a JSX element start at `i` (as opposed to a less-than)? */
+function jsxStartsAt(src, i) {
+  if (src[i] !== "<" || !/[A-Za-z>]/.test(src[i + 1] ?? "")) return false;
+  let k = i - 1;
+  while (k >= 0 && /\s/.test(src[k])) k--;
+  if (k < 0 || "(,=:?&|{[>".includes(src[k])) return true;
+  return /\breturn$/.test(src.slice(Math.max(0, k - 6), k + 1));
+}
+
+/** End (exclusive) of the bracketed run opening at `i` (`src[i] === open`). */
+function scanBalanced(src, i, open, close) {
+  let depth = 0;
+  for (let k = i; k < src.length; k++) {
+    const end = skipLiteral(src, k);
+    if (end !== k) {
+      k = end - 1;
+      continue;
+    }
+    const c = src[k];
+    if (c === open) depth++;
+    else if (c === close) {
+      depth--;
+      if (depth === 0) return k + 1;
+    } else if (c === "<" && jsxStartsAt(src, k)) {
+      k = scanElement(src, k).end - 1;
+    }
+  }
+  return src.length;
+}
+
+const skipSpace = (src, k) => {
+  while (k < src.length && /\s/.test(src[k])) k++;
+  return k;
+};
+
+/**
+ * The element opening at `i`: name ("" for a fragment), attributes and
+ * children, each with its span in `src`.
+ */
+function scanElement(src, i) {
+  const el = { start: i, name: "", attrs: [], children: [], selfClose: false, end: src.length };
+  let k = i + 1;
+  el.name = /^[A-Za-z][\w.:-]*/.exec(src.slice(k, k + 128))?.[0] ?? "";
+  k += el.name.length;
+  for (;;) {
+    k = skipSpace(src, k);
+    if (k >= src.length) return el;
+    if (src[k] === "/" && src[k + 1] === ">") {
+      el.selfClose = true;
+      el.end = k + 2;
+      return el;
+    }
+    if (src[k] === ">") {
+      k++;
+      break;
+    }
+    if (src[k] === "{") {
+      const end = scanBalanced(src, k, "{", "}");
+      el.attrs.push({ name: null, kind: "spread", code: src.slice(k + 1, end - 1), start: k, end });
+      k = end;
+      continue;
+    }
+    const name = /^[A-Za-z_][\w:.-]*/.exec(src.slice(k, k + 128))?.[0];
+    if (!name) {
+      k++;
+      continue;
+    }
+    const start = k;
+    k += name.length;
+    let j = skipSpace(src, k);
+    if (src[j] !== "=") {
+      el.attrs.push({ name, kind: "flag", start, end: k });
+      continue;
+    }
+    j = skipSpace(src, j + 1);
+    if (src[j] === '"' || src[j] === "'") {
+      const close = src.indexOf(src[j], j + 1);
+      const end = close < 0 ? src.length : close + 1;
+      el.attrs.push({ name, kind: "string", value: src.slice(j + 1, end - 1), start, end });
+      k = end;
+    } else if (src[j] === "{") {
+      const end = scanBalanced(src, j, "{", "}");
+      el.attrs.push({ name, kind: "expr", code: src.slice(j + 1, end - 1), start, end });
+      k = end;
+    } else {
+      k = j;
+    }
+  }
+  el.contentStart = k;
+  while (k < src.length) {
+    if (src[k] === "<" && src[k + 1] === "/") {
+      const close = src.indexOf(">", k);
+      el.contentEnd = k;
+      el.end = close < 0 ? src.length : close + 1;
+      return el;
+    }
+    if (src[k] === "<" && /[A-Za-z>]/.test(src[k + 1] ?? "")) {
+      const child = scanElement(src, k);
+      el.children.push({ kind: "el", el: child, start: k, end: child.end });
+      k = child.end;
+      continue;
+    }
+    if (src[k] === "{") {
+      const end = scanBalanced(src, k, "{", "}");
+      el.children.push({ kind: "expr", code: src.slice(k + 1, end - 1), start: k, end });
+      k = end;
+      continue;
+    }
+    let j = k + 1;
+    while (j < src.length && src[j] !== "<" && src[j] !== "{") j++;
+    el.children.push({ kind: "text", raw: src.slice(k, j), start: k, end: j });
+    k = j;
+  }
+  el.contentEnd = src.length;
+  return el;
+}
+
+// ---------------------------------------------------------------------------
+// Declarations
+// ---------------------------------------------------------------------------
+
+const LITERAL_RE = /^(?:"(?:[^"\\\n]|\\.)*"|'(?:[^'\\\n]|\\.)*'|-?\d+(?:\.\d+)?|true|false|null)$/;
+
+/** A literal's value: `{ t: "str" | "num" | "bool" | "undef", v }`, else null. */
+function literalValue(code) {
+  const s = String(code).trim();
+  if (!LITERAL_RE.test(s)) return null;
+  if (s === "true" || s === "false") return { t: "bool", v: s === "true" };
+  if (s === "null") return { t: "undef", v: undefined };
+  if (s[0] === '"' || s[0] === "'") {
+    try {
+      return { t: "str", v: JSON.parse(s[0] === "'" ? `"${s.slice(1, -1).replace(/\\'/g, "'").replace(/"/g, '\\"')}"` : s) };
+    } catch {
+      return null;
+    }
+  }
+  return { t: "num", v: Number(s) };
+}
+
+/** Top-level comma split (outside brackets, strings and JSX). */
+function splitTopLevel(src) {
+  const out = [];
+  let depth = 0;
+  let from = 0;
+  for (let k = 0; k < src.length; k++) {
+    const end = skipLiteral(src, k);
+    if (end !== k) {
+      k = end - 1;
+      continue;
+    }
+    const c = src[k];
+    if ("([{".includes(c)) depth++;
+    else if (")]}".includes(c)) depth--;
+    else if (c === "," && depth === 0) {
+      out.push(src.slice(from, k));
+      from = k + 1;
+    }
+  }
+  out.push(src.slice(from));
+  return out.map((s) => s.trim()).filter(Boolean);
+}
+
+/** `({ a, b = 1, c: d })` → [{ prop, local, fallback }], or null when not one destructured object. */
+function readParams(paramsSrc) {
+  let s = paramsSrc.trim().replace(/^\(/, "").replace(/\)$/, "").trim();
+  s = s.replace(/=\s*\{\s*\}\s*$/, "").trim();
+  if (!s) return [];
+  if (s[0] !== "{" || scanBalanced(s, 0, "{", "}") !== s.length) return null;
+  const params = [];
+  for (const entry of splitTopLevel(s.slice(1, -1))) {
+    const m = /^([A-Za-z_$][\w$]*)(?:\s*:\s*([A-Za-z_$][\w$]*))?(?:\s*=\s*([\s\S]+))?$/.exec(entry);
+    if (!m) return null;
+    params.push({ prop: m[1], local: m[2] ?? m[1], fallback: m[3] === undefined ? null : literalValue(m[3]) });
+  }
+  return params;
+}
+
+/** The JSX a body returns: `(<…>)`, `<…>`, or `{ … return (<…>); }`; its element. */
+function bodyElement(src, k) {
+  k = skipSpace(src, k);
+  if (src[k] === "{") {
+    const end = scanBalanced(src, k, "{", "}");
+    const ret = /\breturn\b\s*/g;
+    ret.lastIndex = k;
+    const m = ret.exec(src);
+    if (!m || m.index > end) return null;
+    const el = bodyElement(src, m.index + m[0].length);
+    return el && { ...el, end };
+  }
+  if (src[k] === "(") {
+    const end = scanBalanced(src, k, "(", ")");
+    const inner = skipSpace(src, k + 1);
+    if (src[inner] !== "<") return null;
+    return { element: scanElement(src, inner), end };
+  }
+  if (src[k] === "<") {
+    const element = scanElement(src, k);
+    return { element, end: element.end };
+  }
+  return null;
+}
+
+/** Local PascalCase components: name → { params, element, start, end } (declaration span). */
+function readComponents(src) {
+  const out = new Map();
+  const arrow = /\b(?:const|let)\s+([A-Z][\w$]*)\s*=\s*(?=\()/g;
+  for (const m of src.matchAll(arrow)) {
+    const open = m.index + m[0].length;
+    const paramsEnd = scanBalanced(src, open, "(", ")");
+    const k = skipSpace(src, paramsEnd);
+    if (src.slice(k, k + 2) !== "=>") continue;
+    const body = bodyElement(src, k + 2);
+    if (!body) continue;
+    let end = skipSpace(src, body.end);
+    end = src[end] === ";" ? end + 1 : body.end;
+    out.set(m[1], { params: readParams(src.slice(open, paramsEnd)), element: body.element, start: m.index, end });
+  }
+  const fn = /\bfunction\s+([A-Z][\w$]*)\s*(?=\()/g;
+  for (const m of src.matchAll(fn)) {
+    const open = m.index + m[0].length;
+    const paramsEnd = scanBalanced(src, open, "(", ")");
+    const body = bodyElement(src, paramsEnd);
+    if (!body) continue;
+    out.set(m[1], { params: readParams(src.slice(open, paramsEnd)), element: body.element, start: m.index, end: body.end });
+  }
+  return out;
+}
+
+function walkElements(el, visit) {
+  visit(el);
+  for (const child of el.children) if (child.kind === "el") walkElements(child.el, visit);
+}
+
+const isPascal = (name) => /^[A-Z]/.test(name);
+
+// ---------------------------------------------------------------------------
+// Substitution
+// ---------------------------------------------------------------------------
+
+/** Evaluate `a + "-t"`, `x + 16`, `y - 4`, a literal or a bare prop; null when it is anything else. */
+function evaluate(code, env) {
+  const tokens = [];
+  const re = /\s*(?:("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*')|(-?\d+(?:\.\d+)?)|([A-Za-z_$][\w$]*)|([+-]))/y;
+  const s = String(code).trim();
+  re.lastIndex = 0;
+  while (re.lastIndex < s.length) {
+    const at = re.lastIndex;
+    const m = re.exec(s);
+    if (!m || m.index !== at) return null;
+    if (m[1]) tokens.push(literalValue(m[1]));
+    else if (m[2]) tokens.push({ t: "num", v: Number(m[2]) });
+    else if (m[3]) {
+      if (m[3] === "true" || m[3] === "false") tokens.push({ t: "bool", v: m[3] === "true" });
+      else if (!env.has(m[3])) return null;
+      else tokens.push(env.get(m[3]));
+    } else tokens.push({ op: m[4] });
+  }
+  if (!tokens.length || tokens[0]?.op) return null;
+  let acc = tokens[0];
+  for (let k = 1; k < tokens.length; k += 2) {
+    const op = tokens[k]?.op;
+    const rhs = tokens[k + 1];
+    if (!op || !rhs || rhs.op) return null;
+    if (["jsx", "code", "undef"].includes(acc.t) || ["jsx", "code", "undef"].includes(rhs.t)) return null;
+    if (op === "+" && (acc.t === "str" || rhs.t === "str")) acc = { t: "str", v: `${acc.v}${rhs.v}` };
+    else if (acc.t === "num" && rhs.t === "num") acc = { t: "num", v: op === "+" ? acc.v + rhs.v : acc.v - rhs.v };
+    else return null;
+  }
+  return acc;
+}
+
+/** Replace prop names inside an expression we cannot evaluate (not keys, not members, not in strings). */
+function substituteText(code, env) {
+  let out = "";
+  for (let k = 0; k < code.length; ) {
+    const end = skipLiteral(code, k);
+    if (end !== k) {
+      out += code.slice(k, end);
+      k = end;
+      continue;
+    }
+    const m = /^[A-Za-z_$][\w$]*/.exec(code.slice(k));
+    if (!m) {
+      out += code[k++];
+      continue;
+    }
+    const word = m[0];
+    const before = code.slice(0, k).trimEnd().slice(-1);
+    const after = code.slice(k + word.length).trimStart()[0];
+    const value = env.get(word);
+    if (value && before !== "." && after !== ":") {
+      out += value.t === "str" ? JSON.stringify(value.v) : value.t === "jsx" || value.t === "code" ? `(${value.code})` : String(value.v);
+    } else out += word;
+    k += word.length;
+  }
+  return out;
+}
+
+/**
+ * Compute every `220 + 182.5 - 4` a substitution left as a whole value (a
+ * figure's `{x: x + 182.5}` once `x` is known), left to right as JS does — so
+ * readers get the literal the transcriber writes. A chain next to `*`, `/` or
+ * a call is left alone.
+ */
+function foldNumbers(code) {
+  const num = String.raw`-?\d+(?:\.\d+)?(?:e[+-]?\d+)?`;
+  const chain = new RegExp(String.raw`(^|[:,[({]\s*)(${num}(?:\s*[+-]\s*${num})+)(?=\s*(?:[,\]})]|$))`, "g");
+  // Strings and comments masked, so no number inside one is touched.
+  let masked = "";
+  for (let k = 0; k < code.length; ) {
+    const end = skipLiteral(code, k);
+    if (end !== k) {
+      masked += "_".repeat(end - k);
+      k = end;
+    } else masked += code[k++];
+  }
+  let out = "";
+  let last = 0;
+  for (const m of masked.matchAll(chain)) {
+    const at = m.index + m[1].length;
+    const terms = [...m[2].matchAll(new RegExp(String.raw`([+-]?)\s*(${num})`, "g"))];
+    let acc = Number(`${terms[0][1]}${terms[0][2]}`);
+    for (const t of terms.slice(1)) acc = t[1] === "-" ? acc - Number(t[2]) : acc + Number(t[2]);
+    out += code.slice(last, at) + String(acc);
+    last = at + m[2].length;
+  }
+  return out + code.slice(last);
+}
+
+const fragmentInner = (code) => {
+  const s = code.trim();
+  return s.startsWith("<>") && s.endsWith("</>") ? s.slice(2, -3) : s;
+};
+
+function serializeAttr(name, value) {
+  if (value.t === "undef" || (value.t === "bool" && !value.v)) return null;
+  if (value.t === "bool") return name;
+  if (value.t === "str") return /["\n]/.test(value.v) ? `${name}={${JSON.stringify(value.v)}}` : `${name}="${value.v}"`;
+  if (value.t === "num") return `${name}={${value.v}}`;
+  return `${name}={${value.code}}`;
+}
+
+/** The template element rendered with `env` substituted. */
+function instantiate(src, el, env) {
+  const head = [el.name];
+  for (const attr of el.attrs) {
+    if (attr.kind !== "expr") {
+      head.push(src.slice(attr.start, attr.end));
+      continue;
+    }
+    const value = evaluate(attr.code, env);
+    if (value) {
+      const text = serializeAttr(attr.name, value);
+      if (text) head.push(text);
+      continue;
+    }
+    head.push(`${attr.name}={${foldNumbers(substituteText(attr.code, env))}}`);
+  }
+  const open = `<${head.join(" ")}`;
+  if (el.selfClose) return `${open} />`;
+  let body = "";
+  for (const child of el.children) {
+    if (child.kind === "text") body += child.raw;
+    else if (child.kind === "el") body += instantiate(src, child.el, env);
+    else body += instantiateExpr(child.code, env);
+  }
+  return `${open}>${body}</${el.name}>`;
+}
+
+/** A child expression: a slot (`{text}`), a guarded part (`{discId && <B …/>}`), or text. */
+function instantiateExpr(code, env) {
+  const bare = /^\s*([A-Za-z_$][\w$]*)\s*$/.exec(code)?.[1];
+  if (bare && env.has(bare)) {
+    const value = env.get(bare);
+    if (value.t === "jsx") return fragmentInner(value.code);
+    if (value.t === "undef" || value.t === "bool") return "";
+    if (value.t === "code") return `{${value.code}}`;
+    return value.t === "str" && !/[<>{}&]/.test(value.v) ? value.v : `{${JSON.stringify(value.v)}}`;
+  }
+  const guard = /^\s*([A-Za-z_$][\w$]*)\s*&&\s*\(?\s*(<[\s\S]*?>)\s*\)?\s*$/.exec(code);
+  if (guard && env.has(guard[1])) {
+    const value = env.get(guard[1]);
+    if (value.t === "undef" || (value.t === "bool" && !value.v) || (value.t === "str" && !value.v)) return "";
+    const at = code.indexOf("<", guard.index + guard[1].length);
+    return instantiate(code, scanElement(code, at), env);
+  }
+  return `{${substituteText(code, env)}}`;
+}
+
+/**
+ * An object or array literal that names nothing outside itself
+ * (`{ borderWidth: "var(--bw-hairline)" }`): every word is a key or a literal.
+ */
+function selfContained(code) {
+  const s = code.trim();
+  if (!/^[{[]/.test(s)) return false;
+  let out = "";
+  for (let k = 0; k < s.length; ) {
+    const end = skipLiteral(s, k);
+    if (end !== k) {
+      out += s[k] === "`" && s.slice(k, end).includes("${") ? "@" : '""';
+      k = end;
+      continue;
+    }
+    out += s[k++];
+  }
+  if (/@|=>|\.\.\./.test(out)) return false;
+  for (const m of out.matchAll(/[A-Za-z_$][\w$]*/g)) {
+    if (/^(?:true|false|null|undefined)$/.test(m[0])) continue;
+    if (/^\s*:/.test(out.slice(m.index + m[0].length))) continue;
+    return false;
+  }
+  return true;
+}
+
+/** The call site's props, or a reason (a spread) when they cannot be read. */
+function callProps(call, params) {
+  const env = new Map();
+  for (const attr of call.attrs) {
+    if (attr.kind === "spread") return { reason: "spread_props" };
+    if (attr.name === "key") continue;
+    if (attr.kind === "flag") env.set(attr.name, { t: "bool", v: true });
+    else if (attr.kind === "string") env.set(attr.name, { t: "str", v: attr.value });
+    else {
+      const code = attr.code.trim();
+      const literal = literalValue(code);
+      if (literal) env.set(attr.name, literal);
+      else if (code.startsWith("<")) env.set(attr.name, { t: "jsx", code });
+      // Any other expression travels as written: it is evaluated where the
+      // call site was, so the instance renders the same. Ids are literal by
+      // contract (lint-components.ts), so the readers still find every part.
+      else env.set(attr.name, { t: "code", code });
+    }
+  }
+  // Locals: the template reads props by their local names, defaults included.
+  const locals = new Map();
+  for (const p of params) {
+    const value = env.get(p.prop) ?? p.fallback ?? { t: "undef", v: undefined };
+    locals.set(p.local, value);
+  }
+  return { env: locals };
+}
+
+const lineCount = (s) => s.split("\n").length - 1;
+
+/**
+ * Is the call site at `at` an expression (`=> <X/>`, `{<X/>}`, `(<X/>)`) rather
+ * than a JSX child? An expression holds ONE element, so a fragment template
+ * keeps its `<>…</>` there; as a child, its parts are spliced in directly.
+ */
+function inExpression(src, at) {
+  let k = at - 1;
+  while (k >= 0 && /\s/.test(src[k])) k--;
+  if (src[k] === ">") return src[k - 1] === "=";
+  return src[k] !== "}";
+}
+
+/**
+ * The declaration's span widened to its whole lines when nothing else shares
+ * them — with the `//` comment lines right above it, which describe it.
+ */
+function wholeLines(src, start, end) {
+  let lineStart = src.lastIndexOf("\n", start - 1) + 1;
+  const lineEnd = src.indexOf("\n", end);
+  const tail = lineEnd < 0 ? src.length : lineEnd;
+  if (src.slice(lineStart, start).trim() || src.slice(end, tail).trim()) return { start, end };
+  while (lineStart > 0) {
+    const prev = src.lastIndexOf("\n", lineStart - 2) + 1;
+    if (!/^\s*\/\//.test(src.slice(prev, lineStart - 1))) break;
+    lineStart = prev;
+  }
+  return { start: lineStart, end: lineEnd < 0 ? src.length : lineEnd + 1 };
+}
+
+/**
+ * Inline every call site of a composite local component.
+ * @param {string} src
+ * @param {{ preserveLines?: boolean }} [options]
+ * @returns {{ src: string, unreadable: Array<{ component: string, line: number, reason: string }>, inlined: number }}
+ */
+export function inlineComponents(src, { preserveLines = true } = {}) {
+  let out = String(src ?? "");
+  const unreadable = [];
+  let inlined = 0;
+  // A composite inside a composite unrolls one level per pass.
+  for (let pass = 0; pass < 4; pass++) {
+    const composites = new Map();
+    // The slide itself (the default export) is where call sites live, never a template.
+    const slideName = /\bexport\s+default\s+(?:function\s+)?([A-Z][\w$]*)/.exec(out)?.[1];
+    for (const [name, c] of readComponents(out)) {
+      if (name === slideName) continue;
+      let calls = false;
+      walkElements(c.element, (e) => {
+        if (isPascal(e.name) && e.name !== name) calls = true;
+      });
+      if (calls) composites.set(name, c);
+    }
+    if (!composites.size) break;
+    const insideTemplate = (at) => [...composites.values()].some((c) => at >= c.start && at < c.end);
+    // A composite another template still calls keeps its declaration this pass.
+    const nested = new Set();
+    for (const c of composites.values()) {
+      walkElements(c.element, (e) => {
+        if (composites.has(e.name)) nested.add(e.name);
+      });
+    }
+    const edits = [];
+    const called = new Set();
+    const kept = new Set();
+    const tag = new RegExp(`<(${[...composites.keys()].join("|")})(?=[\\s/>])`, "g");
+    for (const m of out.matchAll(tag)) {
+      if (insideTemplate(m.index)) continue;
+      const c = composites.get(m[1]);
+      const call = scanElement(out, m.index);
+      const line = lineCount(out.slice(0, m.index)) + 1;
+      called.add(m[1]);
+      const props = c.params ? callProps(call, c.params) : { reason: "unsupported_params" };
+      if (!props.env) {
+        if (!unreadable.some((u) => u.component === m[1] && u.line === line)) {
+          unreadable.push({ component: m[1], line, reason: props.reason });
+        }
+        kept.add(m[1]);
+        continue;
+      }
+      let text = instantiate(out, c.element, props.env);
+      if (!c.element.name && !inExpression(out, m.index)) text = text.replace(/^<>/, "").replace(/<\/>$/, "");
+      if (preserveLines) {
+        text = text.replace(/\s*\n\s*/g, " ").trim() + "\n".repeat(lineCount(out.slice(call.start, call.end)));
+      } else {
+        const indent = /^[ \t]*/.exec(out.slice(out.lastIndexOf("\n", m.index - 1) + 1))[0];
+        text = text
+          .split("\n")
+          .map((l) => l.trim())
+          .filter(Boolean)
+          .join(`\n${indent}`);
+      }
+      edits.push({ start: call.start, end: call.end, text });
+      inlined++;
+    }
+    for (const [name, c] of composites) {
+      if (!called.has(name) || kept.has(name) || nested.has(name)) continue;
+      const span = preserveLines ? c : wholeLines(out, c.start, c.end);
+      edits.push({ start: span.start, end: span.end, text: preserveLines ? "\n".repeat(lineCount(out.slice(c.start, c.end))) : "" });
+    }
+    if (!edits.length) break;
+    edits.sort((a, b) => b.start - a.start);
+    for (const e of edits) out = out.slice(0, e.start) + e.text + out.slice(e.end);
+  }
+  return { src: out, unreadable, inlined };
+}