create-ailk 0.31.0 → 0.33.0

package/dist/lib/render-comparison.d.ts

@@ -14,6 +14,47 @@ export declare const IN_FLIGHT = 4;
 export declare const TEXT_EXPRESSION = "(() => { const root = document.querySelector(\"main\") ?? document.body; return root ? root.innerText : \"\"; })()";
 /** Every JSON-LD script's text, in document order. */
 export declare const JSONLD_EXPRESSION = "Array.from(document.querySelectorAll('script[type=\"application/ld+json\"]'), (s) => s.textContent ?? \"\")";
+/**
+ * A Language item #10734's kind pull lists on /faq or /glossary after the pins,
+ * which step 1 reported as a top-up: removed from the after side only.
+ */
+export interface ExcludedItem {
+    kind: "faq" | "term";
+    slug: string;
+    /** The question or term the read renders it with. */
+    name: string;
+}
+/** `removed` names every excluded key; `refused` says why nothing was excluded. */
+export type Exclusion = {
+    removed: string[];
+} | {
+    refused: string;
+};
+/**
+ * Plain JS run in the after page, so no transform reaches it. Under the kind
+ * pull's position rule (#10734 D3) it removes exactly the reported items, or
+ * removes nothing and answers why: FAQs are the tail of the last `faq`
+ * section's items, matched by question; terms are the tail of their letter
+ * group in the last `glossary-index` section, matched by slug, and a letter
+ * group they leave empty goes with its nav link. A reason never carries an
+ * item's words.
+ */
+export declare const EXCLUDE_SOURCE = "function (document, exclude) {\n  var norm = function (s) { return String(s).replace(/\\s+/g, \" \").trim(); };\n  var firstLine = function (el) {\n    var lines = String(el.innerText || \"\").split(\"\\n\");\n    for (var i = 0; i < lines.length; i++) if (norm(lines[i]) !== \"\") return norm(lines[i]);\n    return \"\";\n  };\n  var last = function (selector) {\n    var all = document.querySelectorAll(selector);\n    return all.length === 0 ? null : all[all.length - 1];\n  };\n  var byTestId = function (root, id) {\n    return Array.from(root.querySelectorAll(\"[data-testid]\")).filter(function (el) { return el.getAttribute(\"data-testid\") === id; });\n  };\n  var faqs = exclude.filter(function (t) { return t.kind === \"faq\"; });\n  var terms = exclude.filter(function (t) { return t.kind === \"term\"; });\n  var items = [];\n  if (faqs.length > 0) {\n    var faq = last('[data-section=\"faq\"]');\n    if (faq === null) return { refused: \"no faq section\" };\n    var all = Array.from(faq.querySelectorAll('[data-testid=\"faq-item-expanded\"], [data-testid=\"faq-item-accordion\"], [data-testid=\"faq-item-grid\"]'));\n    var left = faqs.slice();\n    for (var i = Math.max(0, all.length - faqs.length); i < all.length; i++) {\n      var line = firstLine(all[i]);\n      var at = left.findIndex(function (t) { return norm(t.name) === line; });\n      if (at < 0) return { refused: \"item \" + (i + 1) + \" of \" + all.length + \" in the last faq section is not a reported top-up\" };\n      left.splice(at, 1);\n      items.push(all[i]);\n    }\n    if (left.length > 0) return { refused: \"the last faq section has \" + all.length + \" item(s), fewer than its \" + faqs.length + \" top-up(s)\" };\n  }\n  var glossary = null;\n  var termItems = [];\n  if (terms.length > 0) {\n    glossary = last('[data-section=\"glossary-index\"]');\n    if (glossary === null) return { refused: \"no glossary-index section\" };\n    for (var j = 0; j < terms.length; j++) {\n      var links = byTestId(glossary, \"glossary-index-term-\" + terms[j].slug);\n      var li = links.length === 1 ? links[0].closest(\"li\") : null;\n      if (li === null) return { refused: \"term \" + terms[j].slug + \" is not shown once in the last glossary-index section\" };\n      termItems.push(li);\n    }\n    for (var k = 0; k < terms.length; k++) {\n      var siblings = Array.from(termItems[k].parentElement.children);\n      var later = siblings.slice(siblings.indexOf(termItems[k]) + 1);\n      if (later.some(function (el) { return termItems.indexOf(el) < 0; })) {\n        return { refused: \"term \" + terms[k].slug + \" is not at the tail of its letter group\" };\n      }\n    }\n  }\n  items.forEach(function (el) { el.remove(); });\n  var lists = [];\n  termItems.forEach(function (el) {\n    if (lists.indexOf(el.parentElement) < 0) lists.push(el.parentElement);\n    el.remove();\n  });\n  lists.forEach(function (ul) {\n    if (ul.children.length > 0) return;\n    var group = ul.closest(\"section[data-letter]\");\n    if (group === null) return;\n    var link = byTestId(glossary, \"glossary-index-letter-\" + group.getAttribute(\"data-letter\"))[0];\n    group.remove();\n    if (link === undefined) return;\n    var nav = link.closest(\"nav\");\n    link.remove();\n    if (nav !== null && nav.children.length === 0) nav.remove();\n  });\n  return { removed: exclude.map(function (t) { return t.kind + \"/\" + t.slug; }) };\n}";
+/** The expression the after page evaluates: `EXCLUDE_SOURCE` called on a JSON literal. */
+export declare function exclusionExpression(exclude: readonly ExcludedItem[]): string;
+/**
+ * The after side's JSON-LD without the top-ups' nodes: per kind, the one array
+ * holding a matching node (a `Question` by `name`, a `DefinedTerm` by
+ * `termCode`) must end in exactly those nodes and keep one other. The script
+ * that changed is re-serialized with `serializeJsonLd`'s rule
+ * (`packages/schema/src/json-ld.ts`, restated: no runtime import); every other
+ * keeps its string. Anything else is `refused`, with the scripts untouched.
+ */
+export declare function excludeJsonLd(scripts: readonly string[], exclude: readonly ExcludedItem[]): {
+    scripts: string[];
+} | {
+    refused: string;
+};
 /** An image as 8-bit RGBA, row-major. */
 export interface RgbaImage {
     width: number;
@@ -96,16 +137,22 @@ export interface ViewportComparison {
     jsonLd: JsonLdVerdict;
     /** Absent when the comparison takes no screenshots (the verify step). */
     pixels?: PixelVerdict;
+    /** `afterFull`: the after page before its exclusion, for the eye read. */
     shots?: {
         before: string;
         after: string;
+        afterFull?: string;
     };
+    /** Present only on a page with top-ups whose after side rendered (#10753). */
+    exclusion?: Exclusion;
 }
 export interface PageComparison {
     path: string;
     n: number;
     pass: boolean;
     viewports: ViewportComparison[];
+    /** The excluded top-ups' keys, when every viewport removed them (#10753). */
+    excluded?: string[];
 }
 interface Side {
     origin: string;
@@ -122,6 +169,8 @@ export interface ComparePageOptions {
     screenshots: boolean;
     /** Stores one screenshot under `shots/<name>`. */
     writeShot: (name: string, png: Buffer) => void;
+    /** The top-ups removed from the after side before it is read (#10753); `[]` is none. */
+    exclude?: readonly ExcludedItem[];
 }
 /** One frozen URL at every viewport, before against after. */
 export declare function comparePage(o: ComparePageOptions): Promise<PageComparison>;
@@ -192,6 +241,8 @@ export interface RunComparisonOptions {
     dir: string;
     fetch: typeof globalThis.fetch;
     onLine?: (line: string) => void;
+    /** Per frozen page path, the top-ups its after side leaves out (#10753). */
+    exclude?: Readonly<Record<string, readonly ExcludedItem[]>>;
 }
 /** Every page compared, the sweep run, the evidence written; `pass` gates the step. */
 export declare function runComparison(o: RunComparisonOptions): Promise<ComparisonReport & {

package/dist/lib/render-comparison.js

@@ -35,6 +35,153 @@ export const IN_FLIGHT = 4;
 export const TEXT_EXPRESSION = '(() => { const root = document.querySelector("main") ?? document.body; return root ? root.innerText : ""; })()';
 /** Every JSON-LD script's text, in document order. */
 export const JSONLD_EXPRESSION = 'Array.from(document.querySelectorAll(\'script[type="application/ld+json"]\'), (s) => s.textContent ?? "")';
+const itemKey = (i) => `${i.kind}/${i.slug}`;
+/** `compareText`'s whitespace rule. */
+const collapse = (s) => s.replace(/\s+/g, " ").trim();
+/**
+ * Plain JS run in the after page, so no transform reaches it. Under the kind
+ * pull's position rule (#10734 D3) it removes exactly the reported items, or
+ * removes nothing and answers why: FAQs are the tail of the last `faq`
+ * section's items, matched by question; terms are the tail of their letter
+ * group in the last `glossary-index` section, matched by slug, and a letter
+ * group they leave empty goes with its nav link. A reason never carries an
+ * item's words.
+ */
+export const EXCLUDE_SOURCE = `function (document, exclude) {
+  var norm = function (s) { return String(s).replace(/\\s+/g, " ").trim(); };
+  var firstLine = function (el) {
+    var lines = String(el.innerText || "").split("\\n");
+    for (var i = 0; i < lines.length; i++) if (norm(lines[i]) !== "") return norm(lines[i]);
+    return "";
+  };
+  var last = function (selector) {
+    var all = document.querySelectorAll(selector);
+    return all.length === 0 ? null : all[all.length - 1];
+  };
+  var byTestId = function (root, id) {
+    return Array.from(root.querySelectorAll("[data-testid]")).filter(function (el) { return el.getAttribute("data-testid") === id; });
+  };
+  var faqs = exclude.filter(function (t) { return t.kind === "faq"; });
+  var terms = exclude.filter(function (t) { return t.kind === "term"; });
+  var items = [];
+  if (faqs.length > 0) {
+    var faq = last('[data-section="faq"]');
+    if (faq === null) return { refused: "no faq section" };
+    var all = Array.from(faq.querySelectorAll('[data-testid="faq-item-expanded"], [data-testid="faq-item-accordion"], [data-testid="faq-item-grid"]'));
+    var left = faqs.slice();
+    for (var i = Math.max(0, all.length - faqs.length); i < all.length; i++) {
+      var line = firstLine(all[i]);
+      var at = left.findIndex(function (t) { return norm(t.name) === line; });
+      if (at < 0) return { refused: "item " + (i + 1) + " of " + all.length + " in the last faq section is not a reported top-up" };
+      left.splice(at, 1);
+      items.push(all[i]);
+    }
+    if (left.length > 0) return { refused: "the last faq section has " + all.length + " item(s), fewer than its " + faqs.length + " top-up(s)" };
+  }
+  var glossary = null;
+  var termItems = [];
+  if (terms.length > 0) {
+    glossary = last('[data-section="glossary-index"]');
+    if (glossary === null) return { refused: "no glossary-index section" };
+    for (var j = 0; j < terms.length; j++) {
+      var links = byTestId(glossary, "glossary-index-term-" + terms[j].slug);
+      var li = links.length === 1 ? links[0].closest("li") : null;
+      if (li === null) return { refused: "term " + terms[j].slug + " is not shown once in the last glossary-index section" };
+      termItems.push(li);
+    }
+    for (var k = 0; k < terms.length; k++) {
+      var siblings = Array.from(termItems[k].parentElement.children);
+      var later = siblings.slice(siblings.indexOf(termItems[k]) + 1);
+      if (later.some(function (el) { return termItems.indexOf(el) < 0; })) {
+        return { refused: "term " + terms[k].slug + " is not at the tail of its letter group" };
+      }
+    }
+  }
+  items.forEach(function (el) { el.remove(); });
+  var lists = [];
+  termItems.forEach(function (el) {
+    if (lists.indexOf(el.parentElement) < 0) lists.push(el.parentElement);
+    el.remove();
+  });
+  lists.forEach(function (ul) {
+    if (ul.children.length > 0) return;
+    var group = ul.closest("section[data-letter]");
+    if (group === null) return;
+    var link = byTestId(glossary, "glossary-index-letter-" + group.getAttribute("data-letter"))[0];
+    group.remove();
+    if (link === undefined) return;
+    var nav = link.closest("nav");
+    link.remove();
+    if (nav !== null && nav.children.length === 0) nav.remove();
+  });
+  return { removed: exclude.map(function (t) { return t.kind + "/" + t.slug; }) };
+}`;
+/** The expression the after page evaluates: `EXCLUDE_SOURCE` called on a JSON literal. */
+export function exclusionExpression(exclude) {
+    return `(${EXCLUDE_SOURCE})(document, ${JSON.stringify(exclude)})`;
+}
+const isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+/**
+ * The after side's JSON-LD without the top-ups' nodes: per kind, the one array
+ * holding a matching node (a `Question` by `name`, a `DefinedTerm` by
+ * `termCode`) must end in exactly those nodes and keep one other. The script
+ * that changed is re-serialized with `serializeJsonLd`'s rule
+ * (`packages/schema/src/json-ld.ts`, restated: no runtime import); every other
+ * keeps its string. Anything else is `refused`, with the scripts untouched.
+ */
+export function excludeJsonLd(scripts, exclude) {
+    const parsed = scripts.map((script) => {
+        try {
+            return { value: JSON.parse(script) };
+        }
+        catch {
+            return undefined;
+        }
+    });
+    const changed = new Set();
+    for (const kind of ["faq", "term"]) {
+        const items = exclude.filter((i) => i.kind === kind);
+        if (items.length === 0)
+            continue;
+        const matches = (node, item) => isRecord(node) &&
+            (kind === "faq"
+                ? node["@type"] === "Question" && typeof node["name"] === "string" && collapse(node["name"]) === collapse(item.name)
+                : node["@type"] === "DefinedTerm" && node["termCode"] === item.slug);
+        const found = [];
+        const walk = (value, script) => {
+            if (Array.isArray(value)) {
+                if (value.some((node) => items.some((item) => matches(node, item))))
+                    found.push({ script, array: value });
+                for (const v of value)
+                    walk(v, script);
+            }
+            else if (isRecord(value)) {
+                for (const v of Object.values(value))
+                    walk(v, script);
+            }
+        };
+        parsed.forEach((p, script) => p !== undefined && walk(p.value, script));
+        if (found.length !== 1)
+            return { refused: `${found.length} JSON-LD arrays hold a ${kind} top-up, expected 1` };
+        const { script, array } = found[0];
+        const left = [...items];
+        const tail = array.length > items.length ? array.slice(-items.length) : [];
+        for (const node of tail) {
+            const at = left.findIndex((item) => matches(node, item));
+            if (at < 0)
+                break;
+            left.splice(at, 1);
+        }
+        if (tail.length === 0 || left.length > 0) {
+            return { refused: `the last ${items.length} node(s) of the ${kind} array are not its top-ups` };
+        }
+        array.splice(-items.length);
+        changed.add(script);
+    }
+    return {
+        scripts: scripts.map((script, i) => changed.has(i) ? JSON.stringify(parsed[i].value).replace(/</g, "\\u003c") : script),
+    };
+}
 const PNG_SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
 function paeth(a, b, c) {
     const p = a + b - c;
@@ -179,7 +326,7 @@ function pixelVerdict(before, after, tolerance) {
 function passes(v) {
     return v.verdict === "same" || v.verdict === "within-tolerance";
 }
-async function renderSide(side, path, viewport, screenshot) {
+async function renderSide(side, path, viewport, screenshot, exclude) {
     const failed = (render) => ({ render, text: "", jsonLd: [] });
     await side.page.setViewportSize({ width: viewport.width, height: viewport.height });
     let status;
@@ -198,29 +345,55 @@ async function renderSide(side, path, viewport, screenshot) {
     const settled = new URL(side.page.url()).pathname;
     if (settled !== path)
         return failed(`requested "${path}" but the page settled on "${settled}"`);
+    let full;
+    let dom;
+    if (exclude !== undefined) {
+        if (screenshot)
+            full = await side.page.screenshot({ fullPage: true, animations: "disabled" });
+        const answer = await side.page.evaluate(exclusionExpression(exclude));
+        dom =
+            isRecord(answer) && typeof answer["refused"] === "string"
+                ? { refused: `dom: ${answer["refused"]}` }
+                : isRecord(answer) && Array.isArray(answer["removed"])
+                    ? { removed: exclude.map(itemKey) }
+                    : { refused: "dom: no answer from the page" };
+    }
     const text = await side.page.evaluate(TEXT_EXPRESSION);
-    const jsonLd = await side.page.evaluate(JSONLD_EXPRESSION);
+    const read = await side.page.evaluate(JSONLD_EXPRESSION);
+    let jsonLd = Array.isArray(read) ? read.map(String) : [];
+    let exclusion = dom;
+    if (exclude !== undefined && dom !== undefined && "removed" in dom) {
+        const excluded = excludeJsonLd(jsonLd, exclude);
+        if ("refused" in excluded)
+            exclusion = { refused: `json-ld: ${excluded.refused}` };
+        else
+            jsonLd = excluded.scripts;
+    }
     return {
         render: "ok",
         text: typeof text === "string" ? text : "",
-        jsonLd: Array.isArray(jsonLd) ? jsonLd.map(String) : [],
+        jsonLd,
         ...(screenshot && {
             png: await side.page.screenshot({ fullPage: true, animations: "disabled" }),
         }),
+        ...(full !== undefined && { full }),
+        ...(exclusion !== undefined && { exclusion }),
     };
 }
 /** One frozen URL at every viewport, before against after. */
 export async function comparePage(o) {
     const viewports = [];
+    const exclude = o.exclude !== undefined && o.exclude.length > 0 ? o.exclude : undefined;
     for (const viewport of VIEWPORTS) {
         const before = await renderSide(o.before, o.path, viewport, o.screenshots);
-        const after = await renderSide(o.after, o.path, viewport, o.screenshots);
+        const after = await renderSide(o.after, o.path, viewport, o.screenshots, exclude);
         const rendered = before.render === "ok" && after.render === "ok";
         const result = {
             viewport: viewport.name,
             render: { before: before.render, after: after.render },
             text: rendered ? compareText(before.text, after.text) : { verdict: "not-compared" },
             jsonLd: rendered ? compareJsonLd(before.jsonLd, after.jsonLd) : { verdict: "not-compared" },
+            ...(after.exclusion !== undefined && { exclusion: after.exclusion }),
         };
         if (o.screenshots) {
             if (before.png !== undefined && after.png !== undefined) {
@@ -230,6 +403,10 @@ export async function comparePage(o) {
                 };
                 o.writeShot(shots.before, before.png);
                 o.writeShot(shots.after, after.png);
+                if (after.full !== undefined) {
+                    shots.afterFull = `${o.n}-${viewport.name}-after-full.png`;
+                    o.writeShot(shots.afterFull, after.full);
+                }
                 result.pixels = pixelVerdict(before.png, after.png, o.tolerance);
                 result.shots = shots;
             }
@@ -243,8 +420,12 @@ export async function comparePage(o) {
         v.render.after === "ok" &&
         passes(v.text) &&
         passes(v.jsonLd) &&
-        (v.pixels === undefined || passes(v.pixels)));
-    return { path: o.path, n: o.n, pass, viewports };
+        (v.pixels === undefined || passes(v.pixels)) &&
+        (v.exclusion === undefined || "removed" in v.exclusion));
+    const excluded = exclude !== undefined && viewports.every((v) => v.exclusion !== undefined && "removed" in v.exclusion)
+        ? exclude.map(itemKey)
+        : undefined;
+    return { path: o.path, n: o.n, pass, viewports, ...(excluded !== undefined && { excluded }) };
 }
 // ── The sweep (D9) ──────────────────────────────────────────────────────────
 /** `fn` over `items`, at most `limit` at once; results in input order. */
@@ -299,6 +480,22 @@ export function comparisonMarkdown(report) {
             lines.push(`| ${page.n} | \`${page.path}\` | ${v.viewport} | ${render.replace(/\|/g, "\\|")} | ${cell(v.text)} | ${cell(v.jsonLd)} | ${cell(v.pixels)} | ${shots} |`);
         }
     }
+    const excluding = report.pages.filter((p) => p.viewports.some((v) => v.exclusion !== undefined));
+    if (excluding.length > 0) {
+        lines.push("", "## Excluded kind-pull top-ups (#10734)", "");
+        for (const page of excluding) {
+            for (const key of page.excluded ?? [])
+                lines.push(`- \`${page.path}\`: ${key}`);
+            for (const v of page.viewports) {
+                if (v.shots?.afterFull !== undefined) {
+                    lines.push(`- \`${page.path}\` ${v.viewport} before exclusion: [after](shots/${v.shots.afterFull})`);
+                }
+                if (v.exclusion !== undefined && "refused" in v.exclusion) {
+                    lines.push(`- \`${page.path}\` (${v.viewport}): not excluded — ${v.exclusion.refused}`);
+                }
+            }
+        }
+    }
     const failed = report.sweep.results.filter((r) => r.status !== 200);
     lines.push("", `## Sweep: ${report.sweep.results.length} URL(s) on ${report.after}, ${failed.length} not 200`, "", ...failed.map((r) => `- \`${r.path}\` → ${r.status}`));
     return `${lines.join("\n")}\n`;
@@ -346,6 +543,7 @@ export async function runComparison(o) {
                 : route.continue());
         }
         for (const [i, path] of o.pages.entries()) {
+            const exclude = o.exclude !== undefined && Object.hasOwn(o.exclude, path) ? o.exclude[path] : undefined;
             const result = await comparePage({
                 path,
                 n: i + 1,
@@ -354,6 +552,7 @@ export async function runComparison(o) {
                 tolerance: o.tolerance,
                 screenshots: o.screenshots,
                 writeShot: (name, png) => writeFileSync(join(shotsDir, name), png),
+                ...(exclude !== undefined && { exclude }),
             });
             o.onLine?.(`${result.pass ? "same" : "DIFFERS"} ${path}`);
             pages.push(result);

package/dist/mdx-braces.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Bare `{…}` braces on mdx-body pages (#10773, spec
+ * docs/specs/10773-update-never-refreshes-0-19-spec.md D3, D4).
+ *
+ * MDX reads every `{` in body text as the start of a JavaScript expression.
+ * Under the renderer's `next-mdx-remote` defaults (`blockJS`), an expression
+ * that does not parse fails the page, and one that parses is deleted — so on
+ * an mdx-body page every `{` in text other than a `{/* … *\/}` comment is a
+ * defect. This module is the one lexical rule for that brace:
+ *
+ * - `findBareBraces` names every bare brace in a body, by offset, line and
+ *   column, in one left-to-right pass;
+ * - `escapeBareBraces` inserts one `\` before each, and keeps the result only
+ *   when the site's own MDX parser reads it with no expression left but
+ *   comments — the lexer proposes, the parser disposes.
+ *
+ * Used by `create-ailk update` and, through a byte-identical copy in the
+ * scaffold's `tools/`, by `pnpm mdx-body:check`. Pure: no filesystem and no
+ * imports. It must never contain a double open brace, which the scaffold copy
+ * substitutes as a marker.
+ */
+export interface BareBrace {
+    /** Offset of the `{` in the body. */
+    offset: number;
+    /** 1-based line within the body. */
+    line: number;
+    /** 1-based column within the line. */
+    column: number;
+    /** `comment-like` when the next non-whitespace character is `/`. */
+    kind: "placeholder" | "comment-like";
+}
+/** A minimal mdast node: what `escapeBareBraces` reads from the parser's tree. */
+export interface MdastNode {
+    type: string;
+    value?: unknown;
+    position?: {
+        start?: {
+            line?: number;
+            offset?: number;
+        };
+        end?: {
+            offset?: number;
+        };
+    };
+    children?: MdastNode[];
+}
+/** The site's MDX parser: throws the parser's message (carrying `line` and `reason`) on failure. */
+export type MdxParse = (body: string) => MdastNode;
+export type EscapeResult = {
+    kind: "clean";
+} | {
+    kind: "escaped";
+    text: string;
+    count: number;
+} | {
+    kind: "refused";
+    reason: string;
+};
+/**
+ * Every bare `{` in an MDX body. Skips, in this order of precedence: fenced
+ * code, ESM blocks, backslash escapes, inline code, JSX tags (attribute
+ * expressions included) and `{/* … *\/}` comments. Linear in the body.
+ */
+export declare function findBareBraces(body: string): BareBrace[];
+/** The first expression node left in the tree that is not a comment. */
+export declare function firstExpression(node: MdastNode): MdastNode | undefined;
+/**
+ * Escape every bare brace in `body`, all or nothing: `clean` when there is
+ * none (`parse` is not called), `refused` when a brace is a mangled comment,
+ * the escaped text does not parse, or an expression the escape did not reach
+ * remains; otherwise `escaped`.
+ */
+export declare function escapeBareBraces(body: string, parse: MdxParse): EscapeResult;