@mintlify/common 1.0.1325 → 1.0.1327

package/dist/mdx/server-only/emit/emit.js

@@ -0,0 +1,726 @@
+import { GENERATOR, generate } from 'astring';
+import { stringify as commas } from 'comma-separated-tokens';
+import { attachComments } from 'estree-util-attach-comments';
+import { name as isIdentifierName } from 'estree-util-is-identifier-name';
+import { find, hastToReact, html, svg } from 'property-information';
+import { stringify as spaces } from 'space-separated-tokens';
+import styleToObject from 'style-to-object';
+import { addPartialReferences, newInfo, Rewriter } from './rewrite.js';
+const detach = (value) => (' ' + value).slice(1);
+export class Unsupported extends Error {
+    constructor(construct) {
+        super(`Unsupported MDX construct: ${construct}`);
+    }
+}
+const INDENT = '  ';
+const indents = [];
+const indent = (level) => { var _a; return ((_a = indents[level]) !== null && _a !== void 0 ? _a : (indents[level] = INDENT.repeat(level))); };
+const tableElements = new Set(['table', 'tbody', 'thead', 'tfoot', 'tr']);
+const tableCellElement = new Set(['td', 'th']);
+const dashSomething = /-([a-z])/g;
+const whitespaceOnly = /^[ \t\n\f\r]*$/;
+const styleCache = new Map();
+const styleFields = new Map();
+const infoCache = new Map();
+function propertyInfo(schema, prop) {
+    let cache = infoCache.get(schema);
+    if (!cache) {
+        cache = new Map();
+        infoCache.set(schema, cache);
+    }
+    let info = cache.get(prop);
+    if (!info) {
+        const name = detach(prop);
+        info = find(schema, name);
+        if (cache.size < 10000)
+            cache.set(name, info);
+    }
+    return info;
+}
+const str = (value) => JSON.stringify(value);
+const key = (name) => (isIdentifierName(name) ? name : str(name));
+function parseStyle(value) {
+    const cached = styleCache.get(value);
+    if (cached)
+        return cached;
+    const source = detach(value);
+    const result = {};
+    styleToObject(source, (name, styleValue) => {
+        let property = name;
+        if (property.slice(0, 2) !== '--') {
+            if (property.slice(0, 4) === '-ms-')
+                property = 'ms-' + property.slice(4);
+            property = property.replace(dashSomething, (_, $1) => $1.toUpperCase());
+        }
+        result[property] = styleValue;
+    });
+    if (styleCache.size >= 10000)
+        styleCache.clear();
+    styleCache.set(source, result);
+    return result;
+}
+function objectCode(fields, level) {
+    if (fields.length === 0)
+        return '{}';
+    const pad = indent(level + 1);
+    let code = '{\n' + pad + fields[0];
+    for (let index = 1; index < fields.length; index++)
+        code += ',\n' + pad + fields[index];
+    return code + '\n' + indent(level) + '}';
+}
+function styleField(value, align, level) {
+    const cacheKey = typeof value === 'string' && align === undefined ? level + '\0' + value : '';
+    const cached = cacheKey && styleFields.get(cacheKey);
+    if (cached)
+        return cached;
+    const object = value === undefined
+        ? {}
+        : typeof value === 'object'
+            ? value
+            : parseStyle(String(value));
+    const fields = [];
+    for (const cssProp in object) {
+        if (Object.hasOwn(object, cssProp))
+            fields.push(key(cssProp) + ': ' + str(String(object[cssProp])));
+    }
+    if (align !== undefined)
+        fields.push('textAlign: ' + str(align));
+    const field = 'style: ' + objectCode(fields, level);
+    if (cacheKey) {
+        if (styleFields.size >= 10000)
+            styleFields.clear();
+        styleFields.set(detach(cacheKey), field);
+    }
+    return field;
+}
+function checkUserEstree(node, inFunction) {
+    if (!node || typeof node !== 'object')
+        return false;
+    if (Array.isArray(node)) {
+        let awaits = false;
+        for (const child of node)
+            awaits = checkUserEstree(child, inFunction) || awaits;
+        return awaits;
+    }
+    const value = node;
+    let nested = inFunction;
+    let awaits = false;
+    if (typeof value.type === 'string') {
+        const type = value.type;
+        if (type === 'AwaitExpression' && !inFunction)
+            awaits = true;
+        if (type === 'JSXSpreadChild')
+            throw new Unsupported(type);
+        if (type === 'ArrowFunctionExpression' ||
+            type === 'FunctionExpression' ||
+            type === 'FunctionDeclaration')
+            nested = true;
+    }
+    for (const k in value) {
+        if (k === 'loc' || k === 'range' || k === 'data' || k === 'comments')
+            continue;
+        const child = value[k];
+        if (child && typeof child === 'object')
+            awaits = checkUserEstree(child, nested) || awaits;
+    }
+    return awaits;
+}
+function printEstree(node, level) {
+    return generate(node, {
+        comments: true,
+        generator: GENERATOR,
+        startingIndentLevel: level,
+        indent: INDENT,
+        lineEnd: '\n',
+    });
+}
+function expressionOf(program) {
+    const statement = program === null || program === void 0 ? void 0 : program.body[0];
+    return statement && statement.type === 'ExpressionStatement' ? statement.expression : undefined;
+}
+const isWhitespaceLiteral = (expression) => (expression === null || expression === void 0 ? void 0 : expression.type) === 'Literal' && whitespaceOnly.test(String(expression.value));
+class Emitter {
+    constructor(rewriter) {
+        this.rewriter = rewriter;
+        this.info = newInfo();
+        this.usesJsxs = false;
+        this.usesFragment = false;
+        this.async = false;
+        this.schema = html;
+        this.comments = [];
+    }
+    collectComments(estree, sink = this.comments) {
+        var _a;
+        const comments = (_a = estree === null || estree === void 0 ? void 0 : estree.comments) !== null && _a !== void 0 ? _a : [];
+        sink.push(...comments);
+        if (estree)
+            attachComments(estree, estree.comments);
+    }
+    userExpression(expression, level) {
+        return printEstree(this.userEstree(expression), level);
+    }
+    userEstree(node) {
+        if (checkUserEstree(node, false))
+            this.async = true;
+        const resolved = this.rewriter.resolveImports(node);
+        this.rewriter.rewrite(resolved);
+        return this.rewriter.build(resolved);
+    }
+    call(name, props, children, level, keyArg) {
+        let count = 0;
+        let codes = '';
+        for (const child of children) {
+            if (child.kind === 'empty')
+                continue;
+            codes = count++ === 0 ? child.code : codes + ', ' + child.code;
+        }
+        if (count === 1)
+            props.push('children: ' + codes);
+        else if (count > 1) {
+            props.push('children: [' + codes + ']');
+            this.usesJsxs = true;
+        }
+        return ((count > 1 ? '_jsxs(' : '_jsx(') +
+            name +
+            ', ' +
+            this.object(props, level) +
+            (keyArg === undefined ? '' : ', ' + keyArg) +
+            ')');
+    }
+    children(nodes, level, skipLineBreaks) {
+        const out = [];
+        for (const node of nodes) {
+            if (skipLineBreaks && node.type === 'text' && node.value === '\n')
+                continue;
+            const child = this.node(node, level);
+            if (child)
+                out.push(child);
+        }
+        return out;
+    }
+    node(node, level) {
+        var _a, _b, _c;
+        var _d;
+        switch (node.type) {
+            case 'text': {
+                const value = String(node.value || '');
+                if (!value)
+                    return undefined;
+                return whitespaceOnly.test(value)
+                    ? { kind: 'ws', code: str(value) }
+                    : { kind: 'expr', code: str(value) };
+            }
+            case 'element':
+                return { kind: 'expr', code: this.element(node, level), element: true };
+            case 'mdxJsxFlowElement':
+            case 'mdxJsxTextElement':
+                return {
+                    kind: 'expr',
+                    code: this.mdxElement(node, level),
+                    element: !!node.name,
+                };
+            case 'mdxFlowExpression':
+            case 'mdxTextExpression': {
+                const estree = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree;
+                this.collectComments(estree);
+                const expression = expressionOf(estree);
+                if (!expression)
+                    return { kind: 'empty' };
+                const ws = isWhitespaceLiteral(expression);
+                const code = this.userExpression(expression, level);
+                return ws ? { kind: 'ws', code } : { kind: 'expr', code };
+            }
+            case 'mdxjsEsm':
+                this.comments.push(...((_d = (_c = (_b = node.data) === null || _b === void 0 ? void 0 : _b.estree) === null || _c === void 0 ? void 0 : _c.comments) !== null && _d !== void 0 ? _d : []));
+                return undefined;
+            default:
+                throw new Unsupported(node.type);
+        }
+    }
+    name(name, explicit) {
+        const info = this.info;
+        if (name.includes('.')) {
+            const parts = name.split('.');
+            if (parts.some((part) => !isIdentifierName(part)))
+                throw new Unsupported('member-name');
+            const id = parts[0];
+            const isInScope = this.rewriter.inScope(id);
+            if (!info.references.has(name))
+                info.references.set(name, true);
+            if (!isInScope)
+                info.objects.add(id);
+            return parts.join('.');
+        }
+        if (name.includes(':'))
+            return str(name);
+        if (isIdentifierName(name) && !/^[a-z]/.test(name)) {
+            if (!this.rewriter.inScope(name)) {
+                if (name !== 'MDXLayout' && !info.references.has(name))
+                    info.references.set(name, true);
+                info.components.add(name);
+            }
+            return name;
+        }
+        if (explicit)
+            return str(name);
+        info.tags.add(name);
+        if (!isIdentifierName(name)) {
+            let invalid = info.invalid.get(name);
+            if (invalid === undefined) {
+                invalid = '_component' + info.invalid.size;
+                info.invalid.set(name, invalid);
+            }
+            return invalid;
+        }
+        return '_components.' + name;
+    }
+    element(node, level) {
+        var _a;
+        const parentSchema = this.schema;
+        if (parentSchema.space === 'html' && node.tagName.toLowerCase() === 'svg')
+            this.schema = svg;
+        const explicit = !!((_a = node.data) === null || _a === void 0 ? void 0 : _a._mdxExplicitJsx);
+        const callee = this.name(node.tagName, explicit);
+        const children = this.children(node.children, level + 1, this.schema.space === 'html' && tableElements.has(node.tagName.toLowerCase()));
+        const props = [];
+        let alignValue;
+        let styleValue;
+        let styleIndex = -1;
+        const properties = node.properties;
+        for (const prop in properties) {
+            if (!Object.hasOwn(properties, prop))
+                continue;
+            let value = properties[prop];
+            const info = propertyInfo(this.schema, prop);
+            const falsy = !value;
+            if (value === null ||
+                value === undefined ||
+                value === false ||
+                (typeof value === 'number' && Number.isNaN(value)) ||
+                (falsy && info.boolean))
+                continue;
+            const name = info.space ? hastToReact[info.property] || info.property : info.attribute;
+            if (Array.isArray(value))
+                value = info.commaSeparated ? commas(value) : spaces(value);
+            if (name === 'style') {
+                styleValue = value;
+                styleIndex = props.length;
+                props.push('');
+                continue;
+            }
+            if (value === true) {
+                props.push(key(name) + ': true');
+            }
+            else if (tableCellElement.has(node.tagName) && name === 'align') {
+                alignValue = String(value);
+            }
+            else {
+                props.push(key(name) + ': ' + str(String(value)));
+            }
+        }
+        if (alignValue !== undefined && styleIndex < 0) {
+            styleIndex = props.length;
+            props.push('');
+        }
+        if (styleIndex >= 0)
+            props[styleIndex] = styleField(styleValue, alignValue, level + 1);
+        this.schema = parentSchema;
+        return this.call(callee, props, children, level);
+    }
+    object(fields, level) {
+        return objectCode(fields, level);
+    }
+    mdxElement(node, level) {
+        var _a, _b, _c;
+        const parentSchema = this.schema;
+        if (node.name && parentSchema.space === 'html' && node.name.toLowerCase() === 'svg')
+            this.schema = svg;
+        const explicit = !!((_a = node.data) === null || _a === void 0 ? void 0 : _a._mdxExplicitJsx);
+        let callee;
+        if (node.name)
+            callee = this.name(node.name, explicit);
+        else {
+            this.usesFragment = true;
+            callee = '_Fragment';
+        }
+        const attributeComments = [];
+        const props = [];
+        let spread = false;
+        let keyArg;
+        for (const attribute of node.attributes) {
+            if (attribute.type === 'mdxJsxExpressionAttribute') {
+                const estree = (_b = attribute.data) === null || _b === void 0 ? void 0 : _b.estree;
+                this.collectComments(estree, attributeComments);
+                const object = expressionOf(estree);
+                const first = (object === null || object === void 0 ? void 0 : object.type) === 'ObjectExpression' ? object.properties[0] : undefined;
+                if (!first || first.type !== 'SpreadElement')
+                    throw new Unsupported('spread-attribute');
+                if (first.argument.type === 'ObjectExpression') {
+                    const object = this.userEstree(first.argument);
+                    for (const property of object.properties)
+                        props.push(printEstree(property, level + 1));
+                }
+                else
+                    props.push('...' + this.userExpression(first.argument, level + 1));
+                spread = true;
+                continue;
+            }
+            let value;
+            const raw = attribute.value;
+            if (raw === null || raw === undefined)
+                value = 'true';
+            else if (typeof raw === 'object') {
+                const estree = (_c = raw.data) === null || _c === void 0 ? void 0 : _c.estree;
+                this.collectComments(estree, attributeComments);
+                const expression = expressionOf(estree);
+                if (!expression)
+                    throw new Unsupported('empty-attribute-expression');
+                value = this.userExpression(expression, level + 1);
+            }
+            else
+                value = str(String(raw));
+            if (attribute.name === 'key') {
+                if (spread)
+                    throw new Unsupported('key-after-spread');
+                keyArg = value;
+                continue;
+            }
+            props.push(key(attribute.name) + ': ' + value);
+        }
+        const children = this.children(node.children, level + 1, false);
+        this.comments.push(...attributeComments);
+        this.schema = parentSchema;
+        return this.call(callee, props, children, level, keyArg);
+    }
+}
+const HELPER = `function _missingMdxReference(id, component) {
+  throw new Error("Expected " + (component ? "component" : "object") + " \`" + id + "\` to be defined: you likely forgot to import, pass, or provide it.");
+}`;
+const MDX_CONTENT = `function MDXContent(props = {}) {
+  const {wrapper: MDXLayout} = {
+    ..._provideComponents(),
+    ...props.components
+  };
+  return MDXLayout ? _jsx(MDXLayout, {
+    ...props,
+    children: _jsx(_createMdxContent, {
+      ...props
+    })
+  }) : _createMdxContent(props);
+}`;
+const RESOLVE_HELPER = `function _resolveDynamicMdxSpecifier(d) {
+  if (typeof d !== "string") return d;
+  try {
+    new URL(d);
+    return d;
+  } catch {}
+  if (d.startsWith("/") || d.startsWith("./") || d.startsWith("../")) return new URL(d, _importMetaUrl).href;
+  return d;
+}`;
+const IMPORT_META_URL = `const _importMetaUrl = arguments[0].baseUrl;
+if (!_importMetaUrl) throw new Error("Unexpected missing \`options.baseUrl\` needed to support \`export … from\`, \`import\`, or \`import.meta.url\` when generating \`function-body\`");`;
+const LAYOUT_CONTENT = `function MDXContent(props = {}) {
+  return _jsx(MDXLayout, {
+    ...props,
+    children: _jsx(_createMdxContent, {
+      ...props
+    })
+  });
+}`;
+const identifier = (name) => ({ type: 'Identifier', name });
+const importOf = (source) => ({
+    type: 'AwaitExpression',
+    argument: { type: 'ImportExpression', source },
+});
+const nameOf = (node) => node.type === 'Identifier' ? node.name : String(node.value);
+const isDefault = (node) => node.type === 'Identifier' && node.name === 'default';
+function specifiersToDeclarations(specifiers, init) {
+    const namespace = specifiers.find((specifier) => specifier.type === 'ImportNamespaceSpecifier');
+    const properties = specifiers
+        .filter((specifier) => specifier.type !== 'ImportNamespaceSpecifier')
+        .map((specifier) => {
+        let key = specifier.type === 'ImportSpecifier'
+            ? specifier.imported
+            : specifier.type === 'ExportSpecifier'
+                ? specifier.exported
+                : identifier('default');
+        let value = specifier.local;
+        if (specifier.type === 'ExportSpecifier')
+            [key, value] = [value, key];
+        if (value.type !== 'Identifier')
+            throw new Unsupported('specifier');
+        return {
+            type: 'Property',
+            kind: 'init',
+            shorthand: key.type === 'Identifier' && key.name === value.name,
+            method: false,
+            computed: false,
+            key,
+            value,
+        };
+    });
+    const declarations = [];
+    if (namespace)
+        declarations.push({ type: 'VariableDeclarator', id: namespace.local, init });
+    declarations.push({
+        type: 'VariableDeclarator',
+        id: { type: 'ObjectPattern', properties },
+        init: namespace ? identifier(namespace.local.name) : init,
+    });
+    return declarations;
+}
+function esmReplacement(statement, esm, exportAll) {
+    const declare = (declarations) => ({
+        type: 'VariableDeclaration',
+        kind: 'const',
+        declarations,
+    });
+    if (statement.type === 'ExportDefaultDeclaration') {
+        if (esm.layout)
+            throw new Unsupported('duplicate-layout');
+        esm.layout = true;
+        const declaration = statement.declaration;
+        const init = declaration.type === 'FunctionDeclaration'
+            ? Object.assign(Object.assign({}, declaration), { type: 'FunctionExpression' }) : declaration.type === 'ClassDeclaration'
+            ? Object.assign(Object.assign({}, declaration), { type: 'ClassExpression' }) : declaration;
+        return [
+            declare([
+                { type: 'VariableDeclarator', id: identifier('MDXLayout'), init: init },
+            ]),
+        ];
+    }
+    if (statement.type === 'ImportDeclaration' || statement.type === 'ExportAllDeclaration') {
+        const init = importOf(statement.source);
+        if (statement.type === 'ExportAllDeclaration')
+            return [declare([{ type: 'VariableDeclarator', id: identifier(exportAll()), init }])];
+        return [
+            statement.specifiers.length === 0
+                ? { type: 'ExpressionStatement', expression: init }
+                : declare(specifiersToDeclarations(statement.specifiers, init)),
+        ];
+    }
+    if (statement.type !== 'ExportNamedDeclaration')
+        throw new Unsupported(statement.type);
+    if (statement.source) {
+        const layout = statement.specifiers.find((specifier) => isDefault(specifier.exported));
+        const source = statement.source;
+        const init = () => importOf(source);
+        const replacements = [];
+        if (layout) {
+            if (esm.layout)
+                throw new Unsupported('duplicate-layout');
+            esm.layout = true;
+            replacements.push(declare(specifiersToDeclarations([
+                isDefault(layout.local)
+                    ? { type: 'ImportDefaultSpecifier', local: identifier('MDXLayout') }
+                    : {
+                        type: 'ImportSpecifier',
+                        imported: layout.local,
+                        local: identifier('MDXLayout'),
+                    },
+            ], importOf({ type: 'Literal', value: source.value }))));
+        }
+        const rest = statement.specifiers.filter((specifier) => specifier !== layout);
+        if (rest.length === 0)
+            return replacements;
+        esm.exported.push(...rest.map((specifier) => nameOf(specifier.exported)));
+        return [...replacements, declare(specifiersToDeclarations(rest, init()))];
+    }
+    esm.exported.push(...statement.specifiers.map((specifier) => nameOf(specifier.exported)));
+    if (statement.declaration)
+        return [statement.declaration];
+    const declarators = statement.specifiers
+        .filter((specifier) => specifier.exported.type === 'Identifier' &&
+        specifier.local.type === 'Identifier' &&
+        specifier.local.name !== specifier.exported.name)
+        .map((specifier) => ({
+        type: 'VariableDeclarator',
+        id: specifier.exported,
+        init: specifier.local,
+    }));
+    return declarators.length > 0 ? [declare(declarators)] : [];
+}
+function esmNodes(parent, found = []) {
+    for (const node of parent.children) {
+        if (node.type === 'mdxjsEsm')
+            found.push(node);
+        else if (node.type === 'element' ||
+            node.type === 'mdxJsxFlowElement' ||
+            node.type === 'mdxJsxTextElement')
+            esmNodes(node, found);
+    }
+    return found;
+}
+function esmStatements(root, rewriter) {
+    var _a;
+    const esm = { code: [], exported: [], layout: false };
+    const spreads = [];
+    const exportAll = () => {
+        const name = '_exportAll' + (spreads.length + 1);
+        spreads.push('...' + name);
+        return name;
+    };
+    for (const node of esmNodes(root)) {
+        const estree = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree;
+        if (!estree)
+            throw new Unsupported('esm');
+        attachComments(estree, estree.comments);
+        for (const statement of estree.body) {
+            const declaration = statement.type === 'ExportNamedDeclaration' && statement.declaration;
+            if (declaration)
+                esm.exported.push(...rewriter.exportedNames(statement));
+            for (const replacement of esmReplacement(statement, esm, exportAll)) {
+                checkUserEstree(replacement, true);
+                rewriter.resolveImports(replacement);
+                rewriter.rewrite(replacement);
+                const program = {
+                    type: 'Program',
+                    sourceType: 'module',
+                    body: [rewriter.build(replacement)],
+                };
+                esm.code.push(printEstree(program, 0).replace(/\n$/, ''));
+            }
+        }
+    }
+    esm.exported.unshift(...spreads);
+    return esm;
+}
+function rootKind(node) {
+    var _a;
+    switch (node.type) {
+        case 'text':
+            return node.value ? (whitespaceOnly.test(node.value) ? 'ws' : 'expr') : undefined;
+        case 'element':
+            return 'element';
+        case 'mdxJsxFlowElement':
+        case 'mdxJsxTextElement':
+            return node.name ? 'element' : 'expr';
+        case 'mdxFlowExpression':
+        case 'mdxTextExpression': {
+            const expression = expressionOf((_a = node.data) === null || _a === void 0 ? void 0 : _a.estree);
+            return !expression ? 'empty' : isWhitespaceLiteral(expression) ? 'ws' : 'expr';
+        }
+        default:
+            return undefined;
+    }
+}
+function singleRootElement(root) {
+    const kinds = [];
+    let queue;
+    for (const node of root.children) {
+        const kind = rootKind(node);
+        if (!kind)
+            continue;
+        if (kind === 'ws') {
+            if (queue)
+                queue.push(kind);
+        }
+        else {
+            if (queue)
+                kinds.push(...queue);
+            kinds.push(kind);
+            queue = [];
+        }
+    }
+    return kinds.length === 1 && kinds[0] === 'element';
+}
+export function emitProgram(root) {
+    const rewriter = new Rewriter();
+    const esm = esmStatements(root, rewriter);
+    const emitter = new Emitter(rewriter);
+    rewriter.enterContent(emitter.info);
+    let content;
+    if (singleRootElement(root)) {
+        const single = emitter.children(root.children, 1, false).find((child) => child.kind === 'expr');
+        content = single.code;
+    }
+    else {
+        const raw = emitter.children(root.children, 2, false);
+        const cleaned = [];
+        let queue;
+        for (const child of raw) {
+            if (child.kind === 'ws') {
+                if (queue)
+                    queue.push(child);
+            }
+            else {
+                if (queue)
+                    cleaned.push(...queue);
+                cleaned.push(child);
+                queue = [];
+            }
+        }
+        emitter.usesFragment = true;
+        content = emitter.call('_Fragment', [], cleaned, 1);
+    }
+    const info = emitter.info;
+    addPartialReferences(info);
+    const lines = [];
+    if (emitter.comments.length > 0)
+        lines.push(printEstree({ type: 'Program', sourceType: 'module', body: [], comments: emitter.comments }, 0).replace(/\n$/, ''));
+    lines.push('"use strict";');
+    const runtime = [
+        emitter.usesFragment || rewriter.usesFragment ? 'Fragment: _Fragment' : undefined,
+        'jsx: _jsx',
+        emitter.usesJsxs || rewriter.usesJsxs ? 'jsxs: _jsxs' : undefined,
+    ].filter(Boolean);
+    lines.push('const {' + runtime.join(', ') + '} = arguments[0];');
+    const tags = [...info.tags].sort();
+    const actual = [...info.components];
+    for (const object of info.objects)
+        if (!actual.includes(object))
+            actual.push(object);
+    actual.sort();
+    const provides = tags.length > 0 || actual.length > 0 || info.invalid.size > 0;
+    if (provides || !esm.layout || rewriter.provides)
+        lines.push('const {useMDXComponents: _provideComponents} = arguments[0];');
+    const resolve = rewriter.dynamicImport;
+    if (resolve || rewriter.importMetaUrl)
+        lines.push(IMPORT_META_URL);
+    for (const statement of esm.code)
+        lines.push(statement);
+    const body = [];
+    if (provides) {
+        const declarators = [];
+        let init;
+        if (tags.length > 0) {
+            const defaults = tags.map((tag) => key(tag) + ': ' + str(tag));
+            defaults.push('..._provideComponents()', '...props.components');
+            declarators.push('_components = ' + emitter.object(defaults, 1));
+            init = '_components';
+        }
+        else {
+            init = emitter.object(['..._provideComponents()', '...props.components'], 1);
+        }
+        for (const [id, name] of [...info.invalid].sort(([a], [b]) => a.localeCompare(b)))
+            declarators.push(name + ' = _components[' + str(id) + ']');
+        if (actual.length > 0)
+            declarators.push('{' + actual.join(', ') + '} = ' + init);
+        body.push('const ' + declarators.join(', ') + ';');
+    }
+    const references = [...info.references.keys()].sort();
+    for (const id of references)
+        body.push('if (!' +
+            id +
+            ') _missingMdxReference(' +
+            str(id) +
+            ', ' +
+            String(info.references.get(id)) +
+            ');');
+    lines.push((emitter.async ? 'async ' : '') +
+        'function _createMdxContent(props) {\n' +
+        body.map((line) => indent(1) + line + '\n').join('') +
+        indent(1) +
+        'return ' +
+        content +
+        ';\n}');
+    lines.push(esm.layout ? LAYOUT_CONTENT : MDX_CONTENT);
+    const exported = [...esm.exported, 'default: MDXContent'];
+    lines.push('return {\n' + exported.map((name) => indent(1) + name).join(',\n') + '\n};');
+    if (resolve)
+        lines.push(RESOLVE_HELPER);
+    if (references.length > 0 || rewriter.missingReference)
+        lines.push(HELPER);
+    lines.push('');
+    return lines.join('\n');
+}