@mintlify/common 1.0.1268 → 1.0.1270

package/dist/mdx/plugins/remark/unfoldComponentsForMarkdown.js

@@ -0,0 +1,1414 @@
+import { jsx, toJs } from 'estree-util-to-js';
+import { isObject } from '../../../types/guards.js';
+import { collectModuleWrites, collectPatternNames, forEachCodeChild, } from '../../estreeReferences.js';
+import { getJsxEsmTree } from '../../snippets/getJsxEsmTree.js';
+import { BLOCK_LINK_LABEL, FIRST_PARTY_MARKDOWN_COMPONENT_SOURCE, } from './firstPartyMarkdownComponents.js';
+import { VISIBILITY_FOR_EXPECTED, isVisibilityAudience } from './remarkVisibilityForMarkdown.js';
+import { bindPattern, collectContextFromTree, EVAL_FAILED, evaluateStatic, identifierName, isNoOpSpreadValue, isStaticObject, nodeType, serializeStaticValue, unbindPattern, } from './staticEvaluator.js';
+export const MAX_UNFOLD_OUTPUT_BYTES = 2000000;
+// Charged before each materialization so branching definition chains cannot run
+// exponential call volumes under the byte budget.
+export const MAX_UNFOLD_CALLS = 20000;
+export const MAX_UNFOLD_DEPTH = 24;
+export function createUnfoldBudget() {
+    return {
+        remainingBytes: MAX_UNFOLD_OUTPUT_BYTES,
+        remainingCalls: MAX_UNFOLD_CALLS,
+    };
+}
+export function chargeUnfoldBudget(ctx, cost) {
+    ctx.budget.remainingBytes -= cost;
+    return ctx.budget.remainingBytes >= 0;
+}
+/**
+ * A `for` that statically resolves to `agents` or `signed-out`, as a literal or an expression such
+ * as `for={"agents"}`, with no spread, can never hide content from agents.
+ */
+function isAgentVisibleAudience(openingElement) {
+    const attributes = Array.isArray(openingElement.attributes) ? openingElement.attributes : [];
+    if (attributes.some((attribute) => isObject(attribute) && attribute.type === 'JSXSpreadAttribute')) {
+        return false;
+    }
+    // JSX applies the last of repeated attributes
+    const audience = attributes.findLast((attribute) => isObject(attribute) &&
+        attribute.type === 'JSXAttribute' &&
+        isObject(attribute.name) &&
+        attribute.name.name === 'for');
+    if (!isObject(audience) || !isObject(audience.value))
+        return false;
+    const raw = audience.value;
+    let value = raw.value;
+    if (raw.type === 'JSXExpressionContainer') {
+        // Only literal expressions: the scan has no scope, so names must stay gating
+        const evaluated = evaluateStatic(raw.expression, { scope: new Map() });
+        value = evaluated.ok ? evaluated.value : undefined;
+    }
+    return value === 'agents' || value === 'signed-out';
+}
+/** Collects the components a definition renders; returns true as soon as it finds a gating `Visibility`. */
+function scanRenderedComponents(node, rendered) {
+    if (Array.isArray(node))
+        return node.some((child) => scanRenderedComponents(child, rendered));
+    if (!isObject(node))
+        return false;
+    if (node.type === 'JSXOpeningElement' && isObject(node.name)) {
+        let root = node.name;
+        while (isObject(root) && root.type === 'JSXMemberExpression')
+            root = root.object;
+        if (isObject(root) && typeof root.name === 'string') {
+            if (root.name === 'Visibility' && !isAgentVisibleAudience(node))
+                return true;
+            rendered.add(root.name);
+        }
+    }
+    return Object.entries(node).some(([key, child]) => key !== 'loc' && key !== 'range' && scanRenderedComponents(child, rendered));
+}
+/**
+ * Whether a definition, or any component it renders, may hide content from agents. Degrading such
+ * a usage to its raw children when an unfold limit is hit could expose what its `Visibility`
+ * gates, so it is dropped instead.
+ */
+export function definitionGatesContent(def, defs, seen = new Set()) {
+    if (seen.has(def))
+        return false;
+    seen.add(def);
+    const rendered = new Set();
+    if (scanRenderedComponents(def.body, rendered))
+        return true;
+    for (const name of rendered) {
+        const inner = defs.get(name);
+        if (inner !== undefined && definitionGatesContent(inner, defs, seen))
+            return true;
+    }
+    return false;
+}
+export function chargeUnfoldCall(ctx) {
+    ctx.budget.remainingCalls -= 1;
+    return ctx.budget.remainingCalls >= 0;
+}
+/** The environment holding only values that no write the evaluator cannot see can make stale. */
+export function trustedEnv(ctx) {
+    var _a;
+    return (_a = ctx.trusted) !== null && _a !== void 0 ? _a : { scope: ctx.literalScope };
+}
+// Sentinel in the failed-props set for a spread that could not be evaluated;
+// `*` is not a valid JSX attribute name, so it cannot collide with a real prop.
+export const FAILED_SPREAD = '*';
+export function collectMarkdownComponentContext(tree) {
+    const context = collectContextFromTree(tree);
+    const defs = new Map(getFirstPartyComponentDefs());
+    for (const [name, def] of context.defs)
+        defs.set(name, def);
+    return { defs, moduleScope: context.moduleScope, literalScope: context.literalScope };
+}
+let firstPartyDefsCache;
+export function getFirstPartyComponentDefs() {
+    if (firstPartyDefsCache === undefined) {
+        const tree = getJsxEsmTree(FIRST_PARTY_MARKDOWN_COMPONENT_SOURCE, 'first-party-markdown.jsx');
+        firstPartyDefsCache = collectContextFromTree(tree).defs;
+    }
+    return firstPartyDefsCache;
+}
+export const DROP_ELEMENTS = new Set([
+    'svg',
+    'path',
+    'g',
+    'defs',
+    'clipPath',
+    'rect',
+    'circle',
+    'ellipse',
+    'line',
+    'polygon',
+    'polyline',
+    'use',
+    'script',
+    'style',
+    'head',
+    'link',
+    'meta',
+    'noscript',
+    'template',
+    'canvas',
+]);
+export const UNWRAP_BLOCK_ELEMENTS = new Set([
+    'div',
+    'section',
+    'article',
+    'main',
+    'aside',
+    'header',
+    'footer',
+    'nav',
+    'figure',
+    'figcaption',
+    'p',
+]);
+export const UNWRAP_INLINE_ELEMENTS = new Set(['span', 'label', 'button', 'small', 'u', 'center']);
+const MARKDOWN_INLINE_WRAPPERS = {
+    strong: ['**', '**'],
+    b: ['**', '**'],
+    em: ['*', '*'],
+    i: ['*', '*'],
+    code: ['`', '`'],
+    del: ['~~', '~~'],
+    s: ['~~', '~~'],
+};
+export const HEADING_ELEMENTS = {
+    h1: 1,
+    h2: 2,
+    h3: 3,
+    h4: 4,
+    h5: 5,
+    h6: 6,
+};
+/** Styling and internal hooks that mean nothing once the page is plain markdown. */
+export function isPresentationalAttribute(name) {
+    return name === 'className' || name === 'class' || name === 'style' || name.startsWith('data-');
+}
+const DARK_DISPLAY_CLASSES = new Set([
+    'dark:block',
+    'dark:inline',
+    'dark:inline-block',
+    'dark:flex',
+    'dark:grid',
+]);
+/** Which color scheme a Tailwind class list limits an element to, if any. */
+function colorSchemeOnly(className) {
+    if (typeof className !== 'string')
+        return undefined;
+    const classes = className.split(/\s+/);
+    if (classes.includes('dark:hidden'))
+        return 'light';
+    if (classes.includes('hidden') && classes.some((name) => DARK_DISPLAY_CLASSES.has(name))) {
+        return 'dark';
+    }
+    return undefined;
+}
+function isBlankChild(child) {
+    if (!isObject(child))
+        return false;
+    if (child.type !== 'text' && child.type !== 'JSXText')
+        return false;
+    return typeof child.value === 'string' && child.value.trim() === '';
+}
+/**
+ * Drops a dark-mode-only copy when its light-mode-only twin sits right next to it, since both
+ * carry the same content once their classes are gone. Each light copy pairs with one dark copy,
+ * and a dark-only element without an adjacent twin stays.
+ */
+export function dropPairedDarkOnly(children, classOf) {
+    const schemes = children.map((child) => colorSchemeOnly(classOf(child)));
+    if (!schemes.includes('light') || !schemes.includes('dark'))
+        return [...children];
+    const neighbor = (from, step) => {
+        for (let index = from + step; index >= 0 && index < children.length; index += step) {
+            if (!isBlankChild(children[index]))
+                return index;
+        }
+        return -1;
+    };
+    const pairedLight = new Set();
+    const dropped = new Set();
+    schemes.forEach((scheme, index) => {
+        if (scheme !== 'dark')
+            return;
+        for (const twin of [neighbor(index, -1), neighbor(index, 1)]) {
+            if (twin === -1 || schemes[twin] !== 'light' || pairedLight.has(twin))
+                continue;
+            pairedLight.add(twin);
+            dropped.add(index);
+            return;
+        }
+    });
+    return children.filter((_, index) => !dropped.has(index));
+}
+export const KEEP_TAG_COMPONENTS = new Set(['Variation', 'View', 'Snippet']);
+export const HEADLINE_ATTRIBUTES = ['title', 'label', 'name', 'path'];
+export const GFM_ALERT_PATTERN = /^\[!(NOTE|TIP|IMPORTANT|WARNING|CAUTION)\]/;
+export function prefixBlockquoteLines(text) {
+    return text
+        .split('\n')
+        .map((line) => (line.trim() === '' ? '>' : `> ${line}`))
+        .join('\n');
+}
+function unfoldForeignComponent(node, ctx) {
+    let children = serializeJsxChildren(node.children, ctx).trim();
+    if (children === '') {
+        const childrenAttr = findStaticAttribute(node, 'children', ctx);
+        if (typeof childrenAttr === 'string')
+            children = escapeInterpolatedText(childrenAttr).trim();
+        else if (typeof childrenAttr === 'number')
+            children = String(childrenAttr);
+    }
+    const description = findStaticAttribute(node, 'description', ctx);
+    const alt = findStaticAttribute(node, 'alt', ctx);
+    const body = children !== ''
+        ? children
+        : typeof description === 'string'
+            ? escapeInterpolatedText(description)
+            : typeof alt === 'string'
+                ? escapeInterpolatedText(alt)
+                : '';
+    let title;
+    for (const attributeName of HEADLINE_ATTRIBUTES) {
+        const value = findStaticAttribute(node, attributeName, ctx);
+        if (typeof value === 'string' && value.trim() !== '') {
+            title = value;
+            break;
+        }
+    }
+    const href = findStaticAttribute(node, 'href', ctx);
+    const headline = title === undefined
+        ? undefined
+        : typeof href === 'string' && href !== ''
+            ? `[${escapeLinkLabel(escapeInterpolatedText(title))}](${markdownLinkDestination(href)})`
+            : `**${escapeInterpolatedText(title)}**`;
+    const parts = [headline, body].filter((part) => part !== undefined && part !== '');
+    if (parts.length === 0)
+        return accessibleFallback(node, ctx);
+    return `\n\n${parts.join('\n\n')}\n\n`;
+}
+function carriesChildren(name, ctx) {
+    if (name === undefined)
+        return false;
+    return (name === ctx.propsObjectName || (ctx.restCarriesChildren === true && name === ctx.restName));
+}
+export function escapeInterpolatedText(value) {
+    return value.replace(/[\\{}<>]/g, '\\$&');
+}
+export function markdownLinkDestination(url) {
+    return /[\s()]/.test(url) ? `<${url.replace(/[<>]/g, '\\$&')}>` : url;
+}
+function getJsxElementName(node) {
+    let current = isObject(node.openingElement) ? node.openingElement.name : undefined;
+    const parts = [];
+    while (isObject(current) && current.type === 'JSXMemberExpression') {
+        const property = current.property;
+        if (isObject(property) && typeof property.name === 'string')
+            parts.unshift(property.name);
+        current = current.object;
+    }
+    if (isObject(current) && current.type === 'JSXIdentifier' && typeof current.name === 'string') {
+        parts.unshift(current.name);
+        return parts.join('.');
+    }
+    return undefined;
+}
+function jsxAttributes(node) {
+    const opening = node.openingElement;
+    if (!isObject(opening) || !Array.isArray(opening.attributes))
+        return [];
+    return opening.attributes.filter(isObject);
+}
+function resolveJsxAttribute(attribute, ctx) {
+    const value = attribute.value;
+    if (value === null || value === undefined)
+        return { ok: true, value: true };
+    if (nodeType(value) === 'Literal' && isObject(value) && typeof value.value === 'string') {
+        return { ok: true, value: value.value };
+    }
+    if (nodeType(value) === 'JSXExpressionContainer' && isObject(value)) {
+        return evaluateStatic(value.expression, ctx);
+    }
+    return EVAL_FAILED;
+}
+function findStaticAttribute(node, name, ctx) {
+    const resolved = resolveEffectiveAttribute(node, name, ctx);
+    return resolved.ok ? resolved.value : undefined;
+}
+/** The effective attribute value, honoring order; a spread that may supply it makes it unknown. */
+function resolveEffectiveAttribute(node, name, ctx) {
+    let effective = { ok: true, value: undefined };
+    for (const attribute of jsxAttributes(node)) {
+        if (attribute.type === 'JSXSpreadAttribute') {
+            const spreadName = identifierName(attribute.argument);
+            const unknownKeys = spreadName === undefined
+                ? undefined
+                : spreadName === ctx.propsObjectName
+                    ? ctx.failedProps
+                    : spreadName === ctx.restName
+                        ? ctx.restFailedProps
+                        : undefined;
+            // Unknown keys of a props or rest spread matter only when `name` is one of them
+            const spread = spreadName !== undefined && unknownKeys !== undefined && unknownKeys.size > 0
+                ? unknownKeys.has(name)
+                    ? EVAL_FAILED
+                    : { ok: true, value: ctx.scope.get(spreadName) }
+                : evaluateStatic(attribute.argument, ctx);
+            // Arrays and strings spread only indexed keys, so they cannot supply a named attribute
+            if (spread.ok &&
+                (isNoOpSpreadValue(spread.value) ||
+                    Array.isArray(spread.value) ||
+                    typeof spread.value === 'string')) {
+                continue;
+            }
+            if (!spread.ok || !isStaticObject(spread.value))
+                effective = EVAL_FAILED;
+            else if (Object.hasOwn(spread.value, name)) {
+                effective = { ok: true, value: spread.value[name] };
+            }
+            continue;
+        }
+        const attrName = attribute.name;
+        if (attribute.type === 'JSXAttribute' && isObject(attrName) && attrName.name === name) {
+            effective = resolveJsxAttribute(attribute, ctx);
+        }
+    }
+    return effective;
+}
+function accessibleFallback(node, ctx) {
+    const ariaLabel = findStaticAttribute(node, 'aria-label', ctx);
+    if (typeof ariaLabel === 'string' && ariaLabel.trim() !== '') {
+        return escapeInterpolatedText(ariaLabel);
+    }
+    const title = findStaticAttribute(node, 'title', ctx);
+    if (typeof title === 'string' && title.trim() !== '')
+        return escapeInterpolatedText(title);
+    return '';
+}
+function isAriaHidden(node, ctx) {
+    const value = findStaticAttribute(node, 'aria-hidden', ctx);
+    return value === true || value === 'true';
+}
+function dedentJsxText(raw) {
+    const lines = raw.split('\n');
+    if (lines.length === 1)
+        return raw;
+    let minIndent = Infinity;
+    for (const line of lines.slice(1)) {
+        if (line.trim() === '')
+            continue;
+        const match = line.match(/^[ \t]*/);
+        const indent = match ? match[0].length : 0;
+        minIndent = Math.min(minIndent, indent);
+    }
+    if (!Number.isFinite(minIndent) || minIndent === 0)
+        return raw;
+    return [lines[0], ...lines.slice(1).map((line) => line.slice(minIndent))].join('\n');
+}
+// Code spans and generated image markup keep their own brackets
+const PROTECTED_LABEL_PATTERN = /(`+)[\s\S]*?\1|!\[(?:\\.|[^\]\\])*\]\((?:\\.|[^)\\])*\)/g;
+function escapeBrackets(text) {
+    return text.replace(/(?<!\\)[[\]]/g, '\\$&');
+}
+/** Escapes brackets outside code spans and images, so a label cannot end its link early. */
+export function escapeLinkLabel(text) {
+    var _a;
+    let result = '';
+    let lastIndex = 0;
+    for (const match of text.matchAll(PROTECTED_LABEL_PATTERN)) {
+        const index = (_a = match.index) !== null && _a !== void 0 ? _a : 0;
+        result += escapeBrackets(text.slice(lastIndex, index)) + match[0];
+        lastIndex = index + match[0].length;
+    }
+    return result + escapeBrackets(text.slice(lastIndex));
+}
+// A markdown link label can hold only inline content, so blank lines or headings need another shape
+const BLOCK_CONTENT_PATTERN = /\n[ \t]*\n|^#{1,6}[ \t]/m;
+const HEADING_LINE_PATTERN = /^(#{1,6})[ \t]+(.+?)[ \t]*$/;
+const FENCE_PATTERN = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+/** The first ATX heading line outside fenced code, where `#` lines are comments, not headings. */
+function firstHeadingLine(content) {
+    var _a, _b, _c, _d, _e;
+    let fence;
+    let offset = 0;
+    for (const line of content.split('\n')) {
+        const lineStart = offset;
+        offset += line.length + 1;
+        const fenceMatch = FENCE_PATTERN.exec(line);
+        if (fenceMatch !== null) {
+            const token = (_a = fenceMatch[1]) !== null && _a !== void 0 ? _a : '';
+            const marker = (_b = token[0]) !== null && _b !== void 0 ? _b : '`';
+            if (fence === undefined)
+                fence = { marker, length: token.length };
+            else if (marker === fence.marker &&
+                token.length >= fence.length &&
+                ((_c = fenceMatch[2]) !== null && _c !== void 0 ? _c : '').trim() === '') {
+                fence = undefined;
+            }
+            continue;
+        }
+        if (fence !== undefined)
+            continue;
+        const heading = HEADING_LINE_PATTERN.exec(line);
+        if (heading !== null) {
+            return { index: lineStart, line, hashes: (_d = heading[1]) !== null && _d !== void 0 ? _d : '#', title: (_e = heading[2]) !== null && _e !== void 0 ? _e : '' };
+        }
+    }
+    return undefined;
+}
+/** Links the first heading of block content, or follows the content with a link line. */
+function linkBlockContent(content, href, node, ctx) {
+    const destination = markdownLinkDestination(href);
+    const heading = firstHeadingLine(content);
+    if (heading) {
+        const linked = `${heading.hashes} [${escapeLinkLabel(heading.title)}](${destination})`;
+        const before = content.slice(0, heading.index);
+        const after = content.slice(heading.index + heading.line.length);
+        return `\n\n${before}${linked}${after}\n\n`;
+    }
+    const fallback = accessibleFallback(node, ctx);
+    const label = fallback === '' ? BLOCK_LINK_LABEL : fallback;
+    return `\n\n${content}\n\n[${escapeLinkLabel(label)}](${destination})\n\n`;
+}
+/** A code span whose fence is longer than any backtick run inside it. */
+function codeSpan(text) {
+    var _a;
+    const longestRun = ((_a = text.match(/`+/g)) !== null && _a !== void 0 ? _a : []).reduce((max, run) => Math.max(max, run.length), 0);
+    const fence = '`'.repeat(longestRun + 1);
+    const padding = text.startsWith('`') || text.endsWith('`') ? ' ' : '';
+    return `${fence}${padding}${text}${padding}${fence}`;
+}
+function escapeAttributeValue(value) {
+    return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;');
+}
+function serializeExpressionSource(expression) {
+    if (!isObject(expression))
+        return undefined;
+    try {
+        const program = {
+            type: 'Program',
+            sourceType: 'module',
+            body: [{ type: 'ExpressionStatement', expression }],
+        };
+        const source = toJs(program, { handlers: jsx }).value.trim();
+        return source.endsWith(';') ? source.slice(0, -1) : source;
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+function renderAttribute(name, value) {
+    if (value === true)
+        return ` ${name}`;
+    if (typeof value === 'string')
+        return ` ${name}="${escapeAttributeValue(value)}"`;
+    if (value === false || value === null || value === undefined)
+        return '';
+    return ` ${name}={${serializeStaticValue(value)}}`;
+}
+const ATTRIBUTE_NAME_PATTERN = /^[A-Za-z_$][\w$:.-]*$/;
+/** The keys a spread supplies; props and rest objects supply their known keys. */
+function spreadAttributes(attribute, ctx) {
+    var _a, _b;
+    const spreadName = identifierName(attribute.argument);
+    const unknownKeys = spreadName === undefined
+        ? undefined
+        : spreadName === ctx.propsObjectName
+            ? ((_a = ctx.failedProps) !== null && _a !== void 0 ? _a : new Set())
+            : spreadName === ctx.restName
+                ? ((_b = ctx.restFailedProps) !== null && _b !== void 0 ? _b : new Set())
+                : undefined;
+    const spread = spreadName !== undefined && unknownKeys !== undefined
+        ? { ok: true, value: ctx.scope.get(spreadName) }
+        : evaluateStatic(attribute.argument, ctx);
+    // Arrays and strings spread only indexed keys, which are not attribute names
+    if (spread.ok &&
+        (isNoOpSpreadValue(spread.value) ||
+            Array.isArray(spread.value) ||
+            typeof spread.value === 'string')) {
+        return { known: [], unknown: new Set() };
+    }
+    if (!spread.ok || !isStaticObject(spread.value))
+        return { known: [], unknown: 'all' };
+    const known = Object.entries(spread.value).filter(([key]) => key !== 'children' && ATTRIBUTE_NAME_PATTERN.test(key));
+    return { known, unknown: unknownKeys !== null && unknownKeys !== void 0 ? unknownKeys : new Set() };
+}
+function regenerateTag(node, name, children, ctx) {
+    const attrs = new Map();
+    const isIntrinsic = /^[a-z]/.test(name);
+    const setAttribute = (attrName, rendered) => {
+        attrs.delete(attrName);
+        if (isIntrinsic && isPresentationalAttribute(attrName))
+            return;
+        attrs.set(attrName, rendered);
+    };
+    for (const attribute of jsxAttributes(node)) {
+        if (attribute.type === 'JSXSpreadAttribute') {
+            // A spread may override earlier attributes with values that are not known
+            const { known, unknown } = spreadAttributes(attribute, ctx);
+            if (unknown === 'all')
+                attrs.clear();
+            else
+                for (const key of unknown)
+                    attrs.delete(key);
+            for (const [key, value] of known)
+                setAttribute(key, renderAttribute(key, value));
+            continue;
+        }
+        if (attribute.type !== 'JSXAttribute')
+            continue;
+        const attrName = attribute.name;
+        if (!isObject(attrName) || typeof attrName.name !== 'string')
+            continue;
+        const resolved = resolveJsxAttribute(attribute, ctx);
+        if (resolved.ok) {
+            setAttribute(attrName.name, renderAttribute(attrName.name, resolved.value));
+            continue;
+        }
+        const value = attribute.value;
+        const source = nodeType(value) === 'JSXExpressionContainer' && isObject(value)
+            ? serializeExpressionSource(value.expression)
+            : undefined;
+        setAttribute(attrName.name, source === undefined ? '' : ` ${attrName.name}={${source}}`);
+    }
+    const rendered = [...attrs.values()].join('');
+    if (children.trim() === '')
+        return `<${name}${rendered} />`;
+    // MDX only parses multi-paragraph content inside a tag when the tags stand on their own lines
+    if (children.includes('\n\n')) {
+        return `\n\n<${name}${rendered}>\n\n${children}\n\n</${name}>\n\n`;
+    }
+    return `<${name}${rendered}>${children}</${name}>`;
+}
+function serializeJsxChildren(children, ctx) {
+    if (!Array.isArray(children))
+        return '';
+    let result = '';
+    for (const child of dropPairedDarkOnly(children, (node) => jsxClassName(node, ctx))) {
+        result += serializeJsxNode(child, ctx);
+    }
+    return result;
+}
+function jsxClassName(node, ctx) {
+    var _a;
+    if (!isObject(node) || node.type !== 'JSXElement')
+        return undefined;
+    return (_a = findStaticAttribute(node, 'className', ctx)) !== null && _a !== void 0 ? _a : findStaticAttribute(node, 'class', ctx);
+}
+function serializeJsxNode(node, ctx) {
+    if (!isObject(node))
+        return '';
+    switch (node.type) {
+        case 'JSXText':
+            return typeof node.value === 'string' ? dedentJsxText(node.value) : '';
+        case 'JSXFragment':
+            return serializeJsxChildren(node.children, ctx);
+        case 'JSXExpressionContainer':
+            return serializeJsxExpression(node.expression, ctx);
+        case 'JSXElement':
+            return serializeJsxElement(node, ctx);
+        default:
+            return '';
+    }
+}
+function serializeJsxExpression(expression, ctx) {
+    if (!isObject(expression))
+        return '';
+    if (expression.type === 'JSXEmptyExpression')
+        return '';
+    if (expression.type === 'Identifier' &&
+        typeof expression.name === 'string' &&
+        expression.name === ctx.childrenName &&
+        ctx.childrenMarkdown !== '') {
+        return ctx.childrenMarkdown;
+    }
+    if (expression.type === 'MemberExpression' &&
+        expression.computed !== true &&
+        carriesChildren(identifierName(expression.object), ctx) &&
+        identifierName(expression.property) === 'children' &&
+        ctx.childrenMarkdown !== '') {
+        return ctx.childrenMarkdown;
+    }
+    if (expression.type === 'JSXElement' || expression.type === 'JSXFragment') {
+        return serializeJsxNode(expression, ctx);
+    }
+    if (expression.type === 'ConditionalExpression') {
+        const test = evaluateStatic(expression.test, ctx);
+        if (test.ok) {
+            const branch = test.value ? expression.consequent : expression.alternate;
+            return serializeJsxExpression(branch, ctx);
+        }
+    }
+    if (expression.type === 'LogicalExpression' && expression.operator === '&&') {
+        const test = evaluateStatic(expression.left, ctx);
+        if (test.ok) {
+            return test.value ? serializeJsxExpression(expression.right, ctx) : '';
+        }
+    }
+    if (expression.type === 'LogicalExpression' &&
+        (expression.operator === '||' || expression.operator === '??')) {
+        const left = evaluateStatic(expression.left, ctx);
+        if (left.ok) {
+            const takeLeft = expression.operator === '||'
+                ? Boolean(left.value)
+                : left.value !== null && left.value !== undefined;
+            return takeLeft
+                ? serializeJsxExpression(expression.left, ctx)
+                : serializeJsxExpression(expression.right, ctx);
+        }
+    }
+    const evaluated = evaluateStatic(expression, ctx);
+    if (evaluated.ok) {
+        const value = evaluated.value;
+        if (value === null || value === undefined || value === false || value === true)
+            return '';
+        if (typeof value === 'object')
+            return '';
+        const text = String(value);
+        return ctx.verbatim === true ? text : escapeInterpolatedText(text);
+    }
+    return '';
+}
+function serializeJsxElement(node, ctx) {
+    const name = getJsxElementName(node);
+    if (name === undefined)
+        return '';
+    if (isAriaHidden(node, ctx))
+        return '';
+    if (name === 'Visibility') {
+        const audience = visibilityAudience(node, ctx);
+        if (isAgentAudience(audience))
+            return serializeJsxChildren(node.children, ctx);
+        if (typeof audience === 'string' && !isVisibilityAudience(audience)) {
+            console.warn(`<Visibility for="${audience}"> has an unknown audience — expected ${VISIBILITY_FOR_EXPECTED}. The content was removed from the markdown output.`);
+        }
+        return '';
+    }
+    const isIntrinsic = /^[a-z]/.test(name);
+    if (isIntrinsic) {
+        if (DROP_ELEMENTS.has(name))
+            return accessibleFallback(node, ctx);
+        if (name === 'br')
+            return '\n';
+        if (name === 'hr')
+            return '\n\n---\n\n';
+        if (name === 'blockquote') {
+            const content = serializeJsxChildren(node.children, ctx).trim();
+            if (content === '')
+                return accessibleFallback(node, ctx);
+            return `\n\n${prefixBlockquoteLines(content)}\n\n`;
+        }
+        const headingDepth = HEADING_ELEMENTS[name];
+        if (headingDepth !== undefined) {
+            const text = serializeJsxChildren(node.children, ctx).trim();
+            return text === '' ? '' : `\n\n${'#'.repeat(headingDepth)} ${text}\n\n`;
+        }
+        const inlineWrapper = MARKDOWN_INLINE_WRAPPERS[name];
+        if (inlineWrapper !== undefined) {
+            const innerCtx = name === 'code' ? Object.assign(Object.assign({}, ctx), { verbatim: true }) : ctx;
+            const text = serializeJsxChildren(node.children, innerCtx).trim();
+            if (text === '')
+                return '';
+            return name === 'code' ? codeSpan(text) : `${inlineWrapper[0]}${text}${inlineWrapper[1]}`;
+        }
+        if (name === 'a') {
+            const text = serializeJsxChildren(node.children, ctx).trim();
+            const href = findStaticAttribute(node, 'href', ctx);
+            const label = text !== '' ? text : accessibleFallback(node, ctx);
+            if (typeof href === 'string' && href !== '') {
+                const destination = markdownLinkDestination(href);
+                if (BLOCK_CONTENT_PATTERN.test(text))
+                    return linkBlockContent(text, href, node, ctx);
+                return label === ''
+                    ? `[${escapeLinkLabel(escapeInterpolatedText(href))}](${destination})`
+                    : `[${escapeLinkLabel(label)}](${destination})`;
+            }
+            return label;
+        }
+        if (name === 'img') {
+            const src = findStaticAttribute(node, 'src', ctx);
+            const alt = findStaticAttribute(node, 'alt', ctx);
+            const escapedAlt = typeof alt === 'string' ? escapeInterpolatedText(alt) : '';
+            if (typeof src === 'string' && src !== '') {
+                return `![${escapeLinkLabel(escapedAlt)}](${markdownLinkDestination(src)})`;
+            }
+            return escapedAlt;
+        }
+        if (name === 'iframe' || name === 'embed') {
+            const src = findStaticAttribute(node, 'src', ctx);
+            const label = accessibleFallback(node, ctx);
+            if (typeof src === 'string' && src !== '') {
+                return `\n\n[${escapeLinkLabel(label === '' ? escapeInterpolatedText(src) : label)}](${markdownLinkDestination(src)})\n\n`;
+            }
+            return label === '' ? '' : `\n\n${label}\n\n`;
+        }
+        if (UNWRAP_BLOCK_ELEMENTS.has(name)) {
+            const content = serializeJsxChildren(node.children, ctx);
+            if (content.trim() === '') {
+                const fallback = accessibleFallback(node, ctx);
+                return fallback === '' ? '' : `\n\n${fallback}\n\n`;
+            }
+            return `\n\n${content.trim()}\n\n`;
+        }
+        if (UNWRAP_INLINE_ELEMENTS.has(name)) {
+            const content = serializeJsxChildren(node.children, ctx);
+            return content.trim() === '' ? accessibleFallback(node, ctx) : content;
+        }
+        const children = serializeJsxChildren(node.children, ctx);
+        return regenerateTag(node, name, children.trim(), ctx);
+    }
+    if (KEEP_TAG_COMPONENTS.has(name)) {
+        const children = serializeJsxChildren(node.children, ctx);
+        return regenerateTag(node, name, children.trim(), ctx);
+    }
+    return serializeComponentElement(name === 'Steps' ? withStepDefaults(node, ctx) : node, name, ctx);
+}
+function visibilityAudience(node, ctx) {
+    const resolved = resolveEffectiveAttribute(node, 'for', ctx);
+    if (!resolved.ok)
+        return undefined;
+    // An audience that shows content to agents must resolve the same from literal values alone,
+    // since an object it was read from may have been changed by a write the evaluator cannot see
+    if (isAgentAudience(resolved.value)) {
+        const trusted = resolveEffectiveAttribute(node, 'for', Object.assign(Object.assign({}, ctx), trustedEnv(ctx)));
+        if (!trusted.ok || trusted.value !== resolved.value)
+            return undefined;
+    }
+    return resolved.value;
+}
+function isAgentAudience(audience) {
+    return audience === 'agents' || audience === 'signed-out';
+}
+/** `Steps` numbers its `Step` children and passes its `titleSize` down; a Step's own props win. */
+function withStepDefaults(node, ctx) {
+    if (!Array.isArray(node.children))
+        return node;
+    const titleSize = findStaticAttribute(node, 'titleSize', ctx);
+    let index = 0;
+    // Steps flattens fragments before numbering, so a Step inside `<>…</>` keeps counting
+    const number = (child) => {
+        if (isObject(child) && child.type === 'JSXFragment' && Array.isArray(child.children)) {
+            return Object.assign(Object.assign({}, child), { children: child.children.map(number) });
+        }
+        // A Visibility agents can see is unwrapped, so its Steps keep counting
+        if (isObject(child) &&
+            child.type === 'JSXElement' &&
+            getJsxElementName(child) === 'Visibility' &&
+            Array.isArray(child.children) &&
+            isAgentAudience(visibilityAudience(child, ctx))) {
+            return Object.assign(Object.assign({}, child), { children: child.children.map(number) });
+        }
+        if (!isObject(child) || child.type !== 'JSXElement' || getJsxElementName(child) !== 'Step') {
+            return child;
+        }
+        const opening = child.openingElement;
+        if (!isObject(opening))
+            return child;
+        index += 1;
+        const defaults = [stringJsxAttribute('stepNumber', String(index))];
+        if (typeof titleSize === 'string')
+            defaults.push(stringJsxAttribute('titleSize', titleSize));
+        const attributes = Array.isArray(opening.attributes) ? opening.attributes : [];
+        return Object.assign(Object.assign({}, child), { openingElement: Object.assign(Object.assign({}, opening), { attributes: [...defaults, ...attributes] }) });
+    };
+    return Object.assign(Object.assign({}, node), { children: node.children.map(number) });
+}
+function stringJsxAttribute(name, value) {
+    return {
+        type: 'JSXAttribute',
+        name: { type: 'JSXIdentifier', name },
+        value: { type: 'Literal', value },
+    };
+}
+function serializeComponentElement(node, name, ctx) {
+    const def = ctx.defs.get(name);
+    if (def) {
+        const withinLimits = !ctx.stack.includes(def) && ctx.stack.length < MAX_UNFOLD_DEPTH && chargeUnfoldCall(ctx);
+        if (!withinLimits && definitionGatesContent(def, ctx.defs))
+            return '';
+        if (withinLimits) {
+            const failedProps = new Set();
+            const props = collectStaticProps(node, ctx, failedProps);
+            let childrenMarkdown = serializeJsxChildren(node.children, ctx).trim();
+            let bodyValue;
+            // Body children replace any children attribute or spread, even when they render nothing
+            if (hasJsxBodyChildren(node)) {
+                props.delete('children');
+                failedProps.delete('children');
+                bodyValue = jsxBodyValue(node, ctx);
+            }
+            else if (lastChildrenSource(node, ctx) === 'propsSpread') {
+                childrenMarkdown = ctx.childrenMarkdown;
+                props.delete('children');
+            }
+            const trustedFailed = new Set();
+            const trustedProps = collectStaticProps(node, Object.assign(Object.assign({}, ctx), trustedEnv(ctx)), trustedFailed);
+            const markdown = materializeComponent(def, name, props, childrenMarkdown, ctx, failedProps, bodyValue, { props: trustedProps, failedProps: trustedFailed });
+            if (markdown !== undefined) {
+                if (chargeUnfoldBudget(ctx, markdown.length))
+                    return markdown;
+                return definitionGatesContent(def, ctx.defs) ? '' : childrenMarkdown;
+            }
+            if (definitionGatesContent(def, ctx.defs))
+                return '';
+        }
+    }
+    return unfoldForeignComponent(node, ctx);
+}
+function setKnownProp(props, failed, name, value) {
+    props.set(name, value);
+    if (name !== FAILED_SPREAD)
+        failed === null || failed === void 0 ? void 0 : failed.delete(name);
+}
+function setFailedProp(props, failed, name) {
+    props.delete(name);
+    failed === null || failed === void 0 ? void 0 : failed.add(name);
+}
+/**
+ * JSX drops whitespace-only text that spans lines and empty `{}` or `{/* comment *\/}`
+ * containers, so only other children count as a body.
+ */
+function isJsxBodyChild(child) {
+    if (!isObject(child))
+        return true;
+    if (child.type === 'JSXText') {
+        return !(typeof child.value === 'string' &&
+            child.value.trim() === '' &&
+            child.value.includes('\n'));
+    }
+    if (child.type === 'JSXExpressionContainer') {
+        return nodeType(child.expression) !== 'JSXEmptyExpression';
+    }
+    return true;
+}
+function hasJsxBodyChildren(node) {
+    return Array.isArray(node.children) && node.children.some(isJsxBodyChild);
+}
+/**
+ * When the body is one static expression, such as `<Check>{0}</Check>`, `children` is that value
+ * rather than its markdown text, so `children ? … : …` takes the branch React would.
+ */
+function jsxBodyValue(node, ctx) {
+    if (!Array.isArray(node.children))
+        return undefined;
+    const body = node.children.filter(isJsxBodyChild);
+    const only = body.length === 1 ? body[0] : undefined;
+    if (!isObject(only) || only.type !== 'JSXExpressionContainer')
+        return undefined;
+    const evaluated = evaluateStatic(only.expression, ctx);
+    if (!evaluated.ok || (typeof evaluated.value === 'object' && evaluated.value !== null)) {
+        return undefined;
+    }
+    return { value: evaluated.value };
+}
+function lastChildrenSource(node, ctx) {
+    let source;
+    for (const attribute of jsxAttributes(node)) {
+        if (attribute.type === 'JSXSpreadAttribute' &&
+            carriesChildren(identifierName(attribute.argument), ctx)) {
+            source = 'propsSpread';
+            continue;
+        }
+        if (attribute.type === 'JSXAttribute') {
+            const attrName = attribute.name;
+            if (isObject(attrName) && attrName.name === 'children')
+                source = 'attribute';
+        }
+    }
+    return source;
+}
+function collectStaticProps(node, ctx, failed) {
+    const props = new Map();
+    for (const attribute of jsxAttributes(node)) {
+        if (attribute.type === 'JSXSpreadAttribute') {
+            const spread = evaluateStatic(attribute.argument, ctx);
+            if (spread.ok && isStaticObject(spread.value)) {
+                for (const [key, value] of Object.entries(spread.value)) {
+                    setKnownProp(props, failed, key, value);
+                }
+            }
+            else if (!spread.ok || !isNoOpSpreadValue(spread.value)) {
+                failed === null || failed === void 0 ? void 0 : failed.add(FAILED_SPREAD);
+            }
+            continue;
+        }
+        if (attribute.type !== 'JSXAttribute')
+            continue;
+        const attrName = attribute.name;
+        if (!isObject(attrName) || typeof attrName.name !== 'string')
+            continue;
+        const resolved = resolveJsxAttribute(attribute, ctx);
+        if (resolved.ok)
+            setKnownProp(props, failed, attrName.name, resolved.value);
+        else
+            setFailedProp(props, failed, attrName.name);
+    }
+    return props;
+}
+function isDestructuringPattern(node) {
+    const type = nodeType(node);
+    return type === 'ObjectPattern' || type === 'ArrayPattern';
+}
+/** A destructured key known without evaluation: identifiers and string or number literals. */
+function staticPropertyKey(property) {
+    const key = property.key;
+    if (property.computed !== true) {
+        const name = identifierName(key);
+        if (name !== undefined)
+            return name;
+    }
+    if (nodeType(key) !== 'Literal' || !isObject(key))
+        return undefined;
+    return typeof key.value === 'string' || typeof key.value === 'number'
+        ? String(key.value)
+        : undefined;
+}
+function analyzeParams(params) {
+    var _a;
+    const bindings = [];
+    const unknownNames = new Set();
+    let childrenName = 'children';
+    let propsObjectName;
+    const [param] = params;
+    const first = nodeType(param) === 'AssignmentPattern' && isObject(param) ? param.left : param;
+    const firstName = identifierName(first);
+    if (firstName !== undefined)
+        propsObjectName = firstName;
+    let restName;
+    if (nodeType(first) === 'ObjectPattern' && isObject(first) && Array.isArray(first.properties)) {
+        for (const property of first.properties) {
+            if (nodeType(property) === 'RestElement' && isObject(property)) {
+                restName = identifierName(property.argument);
+                continue;
+            }
+            if (nodeType(property) !== 'Property' || !isObject(property))
+                continue;
+            const propName = staticPropertyKey(property);
+            if (propName === undefined) {
+                collectPatternNames(property.value, unknownNames);
+                continue;
+            }
+            const value = property.value;
+            let localName = propName;
+            let defaultExpression;
+            let pattern;
+            if (nodeType(value) === 'AssignmentPattern' && isObject(value)) {
+                const leftName = identifierName(value.left);
+                if (leftName === undefined && isDestructuringPattern(value.left)) {
+                    pattern = value;
+                }
+                else {
+                    localName = leftName !== null && leftName !== void 0 ? leftName : propName;
+                    defaultExpression = value.right;
+                }
+            }
+            else if (isDestructuringPattern(value)) {
+                pattern = value;
+            }
+            else {
+                localName = (_a = identifierName(value)) !== null && _a !== void 0 ? _a : propName;
+            }
+            bindings.push({ propName, localName, defaultExpression, pattern });
+            if (propName === 'children')
+                childrenName = localName;
+        }
+    }
+    return { bindings, childrenName, propsObjectName, restName, unknownNames };
+}
+function bindDeclarator(declarator, env) {
+    if (nodeType(declarator) !== 'VariableDeclarator' || !isObject(declarator))
+        return;
+    const evaluated = evaluateStatic(declarator.init, env);
+    if (evaluated.ok)
+        bindPattern(declarator.id, evaluated.value, env);
+    else
+        unbindPattern(declarator.id, env);
+}
+function blockScopedNames(statements) {
+    const names = new Set();
+    for (const statement of statements) {
+        if (nodeType(statement) !== 'VariableDeclaration' || !isObject(statement))
+            continue;
+        if (statement.kind === 'var' || !Array.isArray(statement.declarations))
+            continue;
+        for (const declarator of statement.declarations) {
+            if (isObject(declarator))
+                collectPatternNames(declarator.id, names);
+        }
+    }
+    return names;
+}
+/** Function and class declarations, which bind their names for the whole block, not as reached. */
+function declaredFunctionNames(statements) {
+    const names = new Set();
+    for (const statement of statements) {
+        const type = nodeType(statement);
+        if (type !== 'FunctionDeclaration' && type !== 'ClassDeclaration')
+            continue;
+        const name = isObject(statement) ? identifierName(statement.id) : undefined;
+        if (name !== undefined)
+            names.add(name);
+    }
+    return names;
+}
+const NESTED_FUNCTION_TYPES = new Set([
+    'ArrowFunctionExpression',
+    'FunctionExpression',
+    'FunctionDeclaration',
+]);
+/** `var` names anywhere in a body outside nested functions, which hoist to the whole function. */
+function hoistedVarNames(node, names = new Set()) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            hoistedVarNames(child, names);
+        return names;
+    }
+    if (!isObject(node) || typeof node.type !== 'string')
+        return names;
+    if (NESTED_FUNCTION_TYPES.has(node.type) || node.type === 'ClassBody')
+        return names;
+    if (node.type === 'VariableDeclaration' && node.kind === 'var') {
+        const declarations = Array.isArray(node.declarations) ? node.declarations : [];
+        for (const declarator of declarations) {
+            if (isObject(declarator))
+                collectPatternNames(declarator.id, names);
+        }
+    }
+    forEachCodeChild(node, (child) => hoistedVarNames(child, names));
+    return names;
+}
+function findReturnInBlock(block, env) {
+    const statements = Array.isArray(block.body) ? block.body : [];
+    const shadowed = new Map();
+    // Block declarations shadow outer bindings from the start of the block: `let` and `const` are
+    // in their temporal dead zone until reached, and functions and classes are bound throughout
+    const localNames = new Set([
+        ...blockScopedNames(statements),
+        ...declaredFunctionNames(statements),
+    ]);
+    for (const name of localNames) {
+        shadowed.set(name, env.scope.has(name) ? { value: env.scope.get(name) } : undefined);
+    }
+    for (const name of localNames)
+        env.scope.delete(name);
+    const nested = findReturnInStatements(statements, env);
+    if (nested !== undefined)
+        return nested;
+    for (const [name, previous] of shadowed) {
+        if (previous === undefined)
+            env.scope.delete(name);
+        else
+            env.scope.set(name, previous.value);
+    }
+    return undefined;
+}
+const UNRESOLVED_RETURN = Symbol('unresolved-return');
+const STRAIGHT_LINE_STATEMENTS = new Set([
+    'ExpressionStatement',
+    'EmptyStatement',
+    'FunctionDeclaration',
+    'ClassDeclaration',
+    'DebuggerStatement',
+]);
+function findReturnExpression(body, env) {
+    var _a;
+    const type = nodeType(body);
+    if (type === 'ReturnStatement' && isObject(body))
+        return (_a = body.argument) !== null && _a !== void 0 ? _a : null;
+    if (type === 'IfStatement')
+        return findReturnInStatements([body], env);
+    if (type !== undefined && type !== 'BlockStatement')
+        return body;
+    if (!isObject(body) || !Array.isArray(body.body))
+        return undefined;
+    // Every local declaration shadows a page binding of the same name from the start of the body:
+    // `var` hoists, `let` and `const` are in their temporal dead zone, and functions and classes are
+    // bound throughout. Each is rebound as its declaration is reached.
+    const localNames = [
+        ...declaredFunctionNames(body.body),
+        ...blockScopedNames(body.body),
+        ...hoistedVarNames(body.body),
+    ];
+    for (const name of localNames)
+        env.scope.delete(name);
+    return findReturnInStatements(body.body, env);
+}
+/** Anything a statement assigns or writes through, even inside callbacks, is no longer known. */
+function unbindWrites(statement, env) {
+    const { reassigned, mutated } = collectModuleWrites(statement);
+    for (const name of reassigned)
+        env.scope.delete(name);
+    for (const name of mutated)
+        env.scope.delete(name);
+}
+function findReturnInStatements(statements, env) {
+    var _a, _b;
+    for (const statement of statements) {
+        if (nodeType(statement) === 'VariableDeclaration' && isObject(statement)) {
+            const declarations = Array.isArray(statement.declarations) ? statement.declarations : [];
+            for (const declarator of declarations)
+                bindDeclarator(declarator, env);
+            unbindWrites(statement, env);
+            continue;
+        }
+        if (nodeType(statement) === 'ReturnStatement' && isObject(statement)) {
+            return (_a = statement.argument) !== null && _a !== void 0 ? _a : null;
+        }
+        if (nodeType(statement) === 'IfStatement' && isObject(statement)) {
+            const test = evaluateStatic(statement.test, env);
+            if (!test.ok)
+                return UNRESOLVED_RETURN;
+            const branch = test.value ? statement.consequent : statement.alternate;
+            if (branch === undefined || branch === null)
+                continue;
+            const nested = nodeType(branch) === 'BlockStatement' && isObject(branch)
+                ? findReturnInBlock(branch, env)
+                : findReturnInStatements([branch], env);
+            if (nested === UNRESOLVED_RETURN)
+                return UNRESOLVED_RETURN;
+            if (nested !== undefined)
+                return nested;
+            continue;
+        }
+        if (nodeType(statement) === 'BlockStatement' && isObject(statement)) {
+            const nested = findReturnInBlock(statement, env);
+            if (nested === UNRESOLVED_RETURN)
+                return UNRESOLVED_RETURN;
+            if (nested !== undefined)
+                return nested;
+            continue;
+        }
+        if (!STRAIGHT_LINE_STATEMENTS.has((_b = nodeType(statement)) !== null && _b !== void 0 ? _b : ''))
+            return UNRESOLVED_RETURN;
+        unbindWrites(statement, env);
+    }
+    return undefined;
+}
+function isResolvedReturn(expression, env) {
+    const type = nodeType(expression);
+    if (type === 'ConditionalExpression' && isObject(expression)) {
+        return evaluateStatic(expression.test, env).ok;
+    }
+    if (type === 'LogicalExpression' && isObject(expression)) {
+        return evaluateStatic(expression.left, env).ok;
+    }
+    return true;
+}
+/** A definition's scope for one usage: `base` plus its parameters bound from `props`. */
+function bindComponentScope(paramInfo, base, props, failedProps, childrenMarkdown, effectiveChildren) {
+    const scope = new Map(base);
+    if (paramInfo.propsObjectName !== undefined) {
+        const propsObject = {};
+        for (const [propName, value] of props) {
+            if ((failedProps === null || failedProps === void 0 ? void 0 : failedProps.has(propName)) !== true)
+                propsObject[propName] = value;
+        }
+        if (childrenMarkdown !== '')
+            propsObject.children = effectiveChildren;
+        scope.set(paramInfo.propsObjectName, propsObject);
+    }
+    const named = new Set(paramInfo.bindings.map((binding) => binding.propName));
+    let restFailedProps;
+    if (paramInfo.restName !== undefined) {
+        const restObject = {};
+        for (const [propName, value] of props) {
+            if (!named.has(propName) && (failedProps === null || failedProps === void 0 ? void 0 : failedProps.has(propName)) !== true) {
+                restObject[propName] = value;
+            }
+        }
+        if (childrenMarkdown !== '' && !named.has('children'))
+            restObject.children = effectiveChildren;
+        scope.set(paramInfo.restName, restObject);
+        restFailedProps = new Set([...(failedProps !== null && failedProps !== void 0 ? failedProps : [])].filter((propName) => !named.has(propName)));
+    }
+    const env = {
+        scope,
+        propsObjectName: paramInfo.propsObjectName,
+        failedProps,
+        restName: paramInfo.restName,
+        restFailedProps,
+    };
+    // Supplied children are bound first, so later parameter defaults can read them
+    if (childrenMarkdown !== '')
+        scope.set(paramInfo.childrenName, effectiveChildren);
+    for (const binding of paramInfo.bindings) {
+        if (binding.propName === 'children' &&
+            childrenMarkdown !== '' &&
+            binding.pattern === undefined) {
+            continue;
+        }
+        if (binding.pattern !== undefined) {
+            const boundNames = new Set();
+            collectPatternNames(binding.pattern, boundNames);
+            for (const boundName of boundNames)
+                scope.delete(boundName);
+            if (failedProps === null || failedProps === void 0 ? void 0 : failedProps.has(binding.propName))
+                continue;
+            const suppliedPattern = props.get(binding.propName);
+            const hasSuppliedPattern = props.has(binding.propName) && suppliedPattern !== undefined;
+            bindPattern(binding.pattern, hasSuppliedPattern ? suppliedPattern : undefined, env);
+            continue;
+        }
+        if (failedProps === null || failedProps === void 0 ? void 0 : failedProps.has(binding.propName)) {
+            scope.delete(binding.localName);
+            continue;
+        }
+        const supplied = props.get(binding.propName);
+        const hasSupplied = props.has(binding.propName) && supplied !== undefined;
+        if (hasSupplied) {
+            scope.set(binding.localName, supplied);
+            continue;
+        }
+        if (binding.defaultExpression === undefined) {
+            scope.set(binding.localName, undefined);
+            continue;
+        }
+        const evaluated = evaluateStatic(binding.defaultExpression, env);
+        if (evaluated.ok)
+            scope.set(binding.localName, evaluated.value);
+        else
+            scope.delete(binding.localName);
+    }
+    for (const unknownName of paramInfo.unknownNames)
+        scope.delete(unknownName);
+    // A key that cannot be known may have been taken out of the rest object
+    if (paramInfo.restName !== undefined && paramInfo.unknownNames.size > 0) {
+        scope.delete(paramInfo.restName);
+    }
+    if (childrenMarkdown !== '') {
+        scope.set(paramInfo.childrenName, effectiveChildren);
+    }
+    return env;
+}
+/** Every name a function body declares or binds, at any depth. */
+function collectDeclaredNames(node, names = new Set()) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectDeclaredNames(child, names);
+        return names;
+    }
+    if (!isObject(node))
+        return names;
+    if (node.type === 'VariableDeclarator')
+        collectPatternNames(node.id, names);
+    if ((node.type === 'FunctionDeclaration' || node.type === 'ClassDeclaration') &&
+        isObject(node.id) &&
+        typeof node.id.name === 'string') {
+        names.add(node.id.name);
+    }
+    if (Array.isArray(node.params)) {
+        for (const param of node.params)
+            collectPatternNames(param, names);
+    }
+    if (node.type === 'CatchClause')
+        collectPatternNames(node.param, names);
+    forEachCodeChild(node, (child) => collectDeclaredNames(child, names));
+    return names;
+}
+export function materializeComponent(def, name, props, childrenMarkdown, ctx, failedProps, 
+// The static value of a body made of one expression, which `children` keeps over its markdown
+bodyValue, trusted) {
+    var _a, _b;
+    // A spread that could not be evaluated may supply any prop, so nothing about
+    // the usage is knowable; fall back to unresolved instead of defaults.
+    if (failedProps === null || failedProps === void 0 ? void 0 : failedProps.has(FAILED_SPREAD))
+        return undefined;
+    let scopeChildren = bodyValue === null || bodyValue === void 0 ? void 0 : bodyValue.value;
+    if (childrenMarkdown === '') {
+        const childrenProp = props.get('children');
+        if (typeof childrenProp === 'string') {
+            childrenMarkdown = escapeInterpolatedText(childrenProp);
+            scopeChildren = childrenProp;
+        }
+        else if (typeof childrenProp === 'number') {
+            childrenMarkdown = String(childrenProp);
+            scopeChildren = childrenProp;
+        }
+    }
+    const effectiveChildren = scopeChildren !== null && scopeChildren !== void 0 ? scopeChildren : childrenMarkdown;
+    const paramInfo = analyzeParams(def.params);
+    const named = new Set(paramInfo.bindings.map((binding) => binding.propName));
+    const env = bindComponentScope(paramInfo, ctx.moduleScope, props, failedProps, childrenMarkdown, effectiveChildren);
+    // Props not supplied from trusted values are unknown here, so a default cannot stand in for them
+    const untrusted = new Set([...props.keys()].filter((key) => (trusted === null || trusted === void 0 ? void 0 : trusted.props.has(key)) !== true));
+    const trustedEnvironment = bindComponentScope(paramInfo, trustedEnv(ctx).scope, (_a = trusted === null || trusted === void 0 ? void 0 : trusted.props) !== null && _a !== void 0 ? _a : new Map(), new Set([...((_b = trusted === null || trusted === void 0 ? void 0 : trusted.failedProps) !== null && _b !== void 0 ? _b : []), ...untrusted, ...(failedProps !== null && failedProps !== void 0 ? failedProps : [])]), '', '');
+    // Locals may shadow trusted names with values that are not
+    for (const local of collectDeclaredNames(def.body))
+        trustedEnvironment.scope.delete(local);
+    const returnExpression = findReturnExpression(def.body, env);
+    if (returnExpression === UNRESOLVED_RETURN)
+        return undefined;
+    if (returnExpression === undefined)
+        return '';
+    if (!isResolvedReturn(returnExpression, env))
+        return undefined;
+    const serializeContext = Object.assign(Object.assign({ defs: ctx.defs, moduleScope: ctx.moduleScope, literalScope: ctx.literalScope, stack: [...ctx.stack, def], budget: ctx.budget }, env), { trusted: trustedEnvironment, restCarriesChildren: !named.has('children'), childrenMarkdown, childrenName: paramInfo.childrenName });
+    return serializeJsxExpression(returnExpression, serializeContext);
+}
+export function collectUsageProps(node, ctx, failed) {
+    var _a, _b;
+    const props = new Map();
+    for (const attribute of node.attributes) {
+        if (attribute.type === 'mdxJsxExpressionAttribute') {
+            const spread = evaluateStatic(extractProgramExpression((_a = attribute.data) === null || _a === void 0 ? void 0 : _a.estree), {
+                scope: ctx.moduleScope,
+            });
+            if (spread.ok && isStaticObject(spread.value)) {
+                for (const [key, value] of Object.entries(spread.value)) {
+                    setKnownProp(props, failed, key, value);
+                }
+            }
+            else if (!spread.ok || !isNoOpSpreadValue(spread.value)) {
+                failed === null || failed === void 0 ? void 0 : failed.add(FAILED_SPREAD);
+            }
+            continue;
+        }
+        if (attribute.type !== 'mdxJsxAttribute')
+            continue;
+        if (attribute.value === null || attribute.value === undefined) {
+            setKnownProp(props, failed, attribute.name, true);
+            continue;
+        }
+        if (typeof attribute.value === 'string') {
+            setKnownProp(props, failed, attribute.name, attribute.value);
+            continue;
+        }
+        const estree = (_b = attribute.value.data) === null || _b === void 0 ? void 0 : _b.estree;
+        const expression = extractProgramExpression(estree);
+        const evaluated = evaluateStatic(expression, { scope: ctx.moduleScope });
+        if (evaluated.ok)
+            setKnownProp(props, failed, attribute.name, evaluated.value);
+        else
+            setFailedProp(props, failed, attribute.name);
+    }
+    return props;
+}
+export function extractProgramExpression(estree) {
+    if (!isObject(estree) || !Array.isArray(estree.body))
+        return undefined;
+    const [statement] = estree.body;
+    if (nodeType(statement) === 'ExpressionStatement' && isObject(statement)) {
+        return statement.expression;
+    }
+    return undefined;
+}
+/** Whether `node` contains a JSX element or fragment, or only one named `name` when given. */
+export function containsJsx(node, name) {
+    if (Array.isArray(node))
+        return node.some((child) => containsJsx(child, name));
+    if (!isObject(node))
+        return false;
+    if (node.type === 'JSXFragment' && name === undefined)
+        return true;
+    if (node.type === 'JSXElement' && (name === undefined || getJsxElementName(node) === name)) {
+        return true;
+    }
+    let found = false;
+    forEachCodeChild(node, (child) => {
+        found || (found = containsJsx(child, name));
+    });
+    return found;
+}
+/**
+ * Serializes an expression that renders JSX: an element or fragment, or a conditional or logical
+ * expression with JSX in a branch. A branch whose condition cannot be resolved is dropped.
+ */
+export function serializeExpressionJsx(expression, ctx) {
+    const type = nodeType(expression);
+    const isBranching = (type === 'ConditionalExpression' || type === 'LogicalExpression') && containsJsx(expression);
+    if (type !== 'JSXElement' && type !== 'JSXFragment' && !isBranching)
+        return undefined;
+    const serializeContext = {
+        defs: ctx.defs,
+        moduleScope: ctx.moduleScope,
+        literalScope: ctx.literalScope,
+        stack: ctx.stack,
+        budget: ctx.budget,
+        scope: new Map(ctx.moduleScope),
+        childrenMarkdown: '',
+        childrenName: 'children',
+    };
+    return serializeJsxExpression(expression, serializeContext);
+}