@mintlify/common 1.0.1269 → 1.0.1270

package/dist/mdx/snippets/resolveImport/snippetDeclarations.js

@@ -0,0 +1,655 @@
+import { jsx, toJs } from 'estree-util-to-js';
+import { isObject } from '../../../types/guards.js';
+import { collectFreeReferences, collectPatternNames, forEachCodeChild, visitReferences, } from '../../estreeReferences.js';
+import { getAST } from '../../remark.js';
+import { estreeIsProgram, isMdxJsEsm } from '../../utils.js';
+import { moduleExportName } from '../importedExportName.js';
+function statementDeclaredNames(statement) {
+    const names = new Set();
+    const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+    if (declaration == null)
+        return names;
+    if (declaration.type === 'VariableDeclaration') {
+        for (const declarator of declaration.declarations) {
+            collectPatternNames(declarator.id, names);
+        }
+    }
+    else if ((declaration.type === 'FunctionDeclaration' || declaration.type === 'ClassDeclaration') &&
+        declaration.id != null) {
+        names.add(declaration.id.name);
+    }
+    return names;
+}
+export function isolateExportedDeclarator(tree, name) {
+    var _a;
+    for (const node of tree.children) {
+        if (!isMdxJsEsm(node) || !estreeIsProgram(node))
+            continue;
+        for (const statement of node.data.estree.body) {
+            if (statement.type !== 'ExportNamedDeclaration' ||
+                ((_a = statement.declaration) === null || _a === void 0 ? void 0 : _a.type) !== 'VariableDeclaration') {
+                continue;
+            }
+            const declarator = statement.declaration.declarations.find((candidate) => candidate.id.type === 'Identifier' && candidate.id.name === name);
+            if (declarator === undefined)
+                continue;
+            const isolated = Object.assign(Object.assign({}, node.data.estree), { body: [
+                    Object.assign(Object.assign({}, statement), { declaration: Object.assign(Object.assign({}, statement.declaration), { declarations: [declarator] }) }),
+                ] });
+            return getAST(toJs(isolated, { handlers: jsx }).value);
+        }
+    }
+    return tree;
+}
+/** Names a module makes importable: named export declarations, specifiers, and default. */
+export function collectExportedNames(tree) {
+    const names = new Set();
+    for (const node of tree.children) {
+        if (!isMdxJsEsm(node) || !estreeIsProgram(node))
+            continue;
+        for (const statement of node.data.estree.body) {
+            if (statement.type === 'ExportDefaultDeclaration') {
+                names.add('default');
+                continue;
+            }
+            if (statement.type !== 'ExportNamedDeclaration')
+                continue;
+            // `export { local as "Name" }` exports a string name, which imports can still request
+            for (const specifier of statement.specifiers)
+                names.add(moduleExportName(specifier.exported));
+            for (const name of statementDeclaredNames(statement))
+                names.add(name);
+        }
+    }
+    return names;
+}
+/** Top-level bindings that only hold their value once their declaration runs: variables and classes. */
+function collectInitializedBindingNames(tree) {
+    const names = new Set();
+    for (const node of tree.children) {
+        if (!isMdxJsEsm(node) || !estreeIsProgram(node))
+            continue;
+        for (const statement of node.data.estree.body) {
+            const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+            if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) !== 'VariableDeclaration' && (declaration === null || declaration === void 0 ? void 0 : declaration.type) !== 'ClassDeclaration') {
+                continue;
+            }
+            for (const name of statementDeclaredNames(statement))
+                names.add(name);
+        }
+    }
+    return names;
+}
+/** Every top-level lexical binding in the tree's ESM statements, exported or not. */
+export function collectTopLevelBindingNames(tree) {
+    const names = new Set();
+    for (const node of tree.children) {
+        if (!isMdxJsEsm(node) || !estreeIsProgram(node))
+            continue;
+        for (const statement of node.data.estree.body) {
+            if (statement.type === 'ImportDeclaration') {
+                for (const specifier of statement.specifiers)
+                    names.add(specifier.local.name);
+                continue;
+            }
+            if (statement.type === 'ExportNamedDeclaration' ||
+                statement.type === 'VariableDeclaration' ||
+                statement.type === 'FunctionDeclaration' ||
+                statement.type === 'ClassDeclaration') {
+                for (const name of statementDeclaredNames(statement))
+                    names.add(name);
+                continue;
+            }
+            if (statement.type === 'ExportDefaultDeclaration' &&
+                (statement.declaration.type === 'FunctionDeclaration' ||
+                    statement.declaration.type === 'ClassDeclaration') &&
+                statement.declaration.id != null) {
+                names.add(statement.declaration.id.name);
+            }
+        }
+    }
+    return names;
+}
+function forEachShorthandProperty(node, callback) {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            forEachShorthandProperty(child, callback);
+        return;
+    }
+    if (!isObject(node))
+        return;
+    if (node.type === 'Property' && node.shorthand === true)
+        callback(node);
+    forEachCodeChild(node, (child) => forEachShorthandProperty(child, callback));
+}
+function shorthandValueName(value) {
+    if (!isObject(value))
+        return undefined;
+    if (value.type === 'AssignmentPattern' && isObject(value.left))
+        return value.left.name;
+    return value.name;
+}
+function renameName(identifier, renames) {
+    if (!isObject(identifier) || typeof identifier.name !== 'string')
+        return;
+    const next = renames.get(identifier.name);
+    if (next !== undefined)
+        identifier.name = next;
+}
+function renamePatternBindings(pattern, renames) {
+    if (!isObject(pattern))
+        return;
+    switch (pattern.type) {
+        case 'Identifier':
+            renameName(pattern, renames);
+            return;
+        case 'AssignmentPattern':
+            renamePatternBindings(pattern.left, renames);
+            return;
+        case 'RestElement':
+            renamePatternBindings(pattern.argument, renames);
+            return;
+        case 'ObjectPattern': {
+            const properties = Array.isArray(pattern.properties) ? pattern.properties : [];
+            for (const property of properties) {
+                if (!isObject(property))
+                    continue;
+                renamePatternBindings(property.type === 'RestElement' ? property.argument : property.value, renames);
+            }
+            return;
+        }
+        case 'ArrayPattern': {
+            const elements = Array.isArray(pattern.elements) ? pattern.elements : [];
+            for (const element of elements)
+                renamePatternBindings(element, renames);
+            return;
+        }
+        default:
+            return;
+    }
+}
+/** Renames module-level references in place; `renameBindings` also renames the node's own declaration. */
+function renameModuleBindings(node, renames, renameBindings) {
+    forEachShorthandProperty(node, (property) => {
+        if (isObject(property.key))
+            property.key = Object.assign({}, property.key);
+    });
+    visitReferences(node, new Set(), {
+        reference: (identifier) => renameName(identifier, renames),
+    });
+    if (renameBindings && isObject(node)) {
+        if (node.type === 'VariableDeclaration' && Array.isArray(node.declarations)) {
+            for (const declarator of node.declarations) {
+                if (isObject(declarator))
+                    renamePatternBindings(declarator.id, renames);
+            }
+        }
+        else {
+            renameName(node.id, renames);
+        }
+    }
+    forEachShorthandProperty(node, (property) => {
+        if (isObject(property.key) && shorthandValueName(property.value) !== property.key.name) {
+            property.shorthand = false;
+        }
+    });
+}
+/**
+ * Orders items after their dependencies. Items in a dependency cycle keep their original order,
+ * since `var` cycles are valid and their values depend on which initializer runs first.
+ */
+function orderByDependencies(items, dependenciesOf) {
+    const position = new Map(items.map((item, index) => [item, index]));
+    const visitIndex = new Map();
+    const lowLink = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const ordered = [];
+    const connect = (item) => {
+        var _a, _b, _c, _d;
+        const index = visitIndex.size;
+        visitIndex.set(item, index);
+        lowLink.set(item, index);
+        stack.push(item);
+        onStack.add(item);
+        for (const dependency of dependenciesOf(item)) {
+            if (!position.has(dependency))
+                continue;
+            if (!visitIndex.has(dependency)) {
+                connect(dependency);
+                lowLink.set(item, Math.min((_a = lowLink.get(item)) !== null && _a !== void 0 ? _a : index, (_b = lowLink.get(dependency)) !== null && _b !== void 0 ? _b : index));
+            }
+            else if (onStack.has(dependency)) {
+                lowLink.set(item, Math.min((_c = lowLink.get(item)) !== null && _c !== void 0 ? _c : index, (_d = visitIndex.get(dependency)) !== null && _d !== void 0 ? _d : index));
+            }
+        }
+        if (lowLink.get(item) !== index)
+            return;
+        const component = [];
+        for (let member = stack.pop(); member !== undefined; member = stack.pop()) {
+            onStack.delete(member);
+            component.push(member);
+            if (member === item)
+                break;
+        }
+        component.sort((a, b) => { var _a, _b; return ((_a = position.get(a)) !== null && _a !== void 0 ? _a : 0) - ((_b = position.get(b)) !== null && _b !== void 0 ? _b : 0); });
+        ordered.push(...component);
+    };
+    for (const item of items)
+        if (!visitIndex.has(item))
+            connect(item);
+    return ordered;
+}
+/**
+ * Orders units so each follows the units it reads while initializing. Reads inside function and
+ * method bodies run later, so they never force an order, which keeps cycles through them safe.
+ */
+function orderByEagerReads(selected, units) {
+    // Units are collected in source order, so their first appearance gives their position
+    const sourceOrder = new Map();
+    for (const unit of units.values()) {
+        if (!sourceOrder.has(unit))
+            sourceOrder.set(unit, sourceOrder.size);
+    }
+    const inSourceOrder = [...selected].sort((a, b) => { var _a, _b; return ((_a = sourceOrder.get(a)) !== null && _a !== void 0 ? _a : 0) - ((_b = sourceOrder.get(b)) !== null && _b !== void 0 ? _b : 0); });
+    return orderByDependencies(inSourceOrder, (unit) => [...collectFreeReferences(unit.declaration, true)].flatMap((reference) => {
+        const dependency = units.get(reference);
+        return dependency === undefined ? [] : [dependency];
+    }));
+}
+function serializeDeclaration(program, declaration) {
+    return toJs(Object.assign(Object.assign({}, program), { body: [declaration] }), { handlers: jsx }).value;
+}
+/** Indexes a module's declarations by name, split per declarator, plus its export aliases. */
+function collectDeclarationUnits(tree) {
+    const units = new Map();
+    const aliases = new Map();
+    const register = (program, declaration) => {
+        const pieces = declaration.type === 'VariableDeclaration'
+            ? declaration.declarations.map((declarator) => (Object.assign(Object.assign({}, declaration), { declarations: [declarator] })))
+            : [declaration];
+        for (const piece of pieces) {
+            const names = statementDeclaredNames(piece);
+            if (names.size === 0)
+                continue;
+            const references = collectFreeReferences(piece);
+            for (const name of names)
+                references.delete(name);
+            const unit = { names, references, declaration: piece, program };
+            for (const name of names) {
+                if (!units.has(name))
+                    units.set(name, unit);
+            }
+        }
+    };
+    for (const node of tree.children) {
+        if (!isMdxJsEsm(node) || !estreeIsProgram(node))
+            continue;
+        const program = node.data.estree;
+        for (const statement of program.body) {
+            if (statement.type === 'VariableDeclaration' ||
+                statement.type === 'FunctionDeclaration' ||
+                statement.type === 'ClassDeclaration') {
+                register(program, statement);
+                continue;
+            }
+            if (statement.type === 'ExportDefaultDeclaration') {
+                const declaration = statement.declaration;
+                if ((declaration.type === 'FunctionDeclaration' || declaration.type === 'ClassDeclaration') &&
+                    declaration.id != null) {
+                    // The name is a module binding even though the statement is a default export
+                    register(program, declaration);
+                }
+                continue;
+            }
+            if (statement.type !== 'ExportNamedDeclaration')
+                continue;
+            if (statement.declaration != null) {
+                register(program, statement.declaration);
+                continue;
+            }
+            // A re-export names a binding in another module, so it is not an alias of a local
+            if (statement.source != null)
+                continue;
+            for (const specifier of statement.specifiers) {
+                if (specifier.local.type === 'Identifier') {
+                    aliases.set(moduleExportName(specifier.exported), specifier.local.name);
+                }
+            }
+        }
+    }
+    return { units, aliases };
+}
+/** The local binding behind an export name, following `export { local as name }`. */
+export function exportedBindingName(tree, exportName) {
+    var _a;
+    return (_a = collectDeclarationUnits(tree).aliases.get(exportName)) !== null && _a !== void 0 ? _a : exportName;
+}
+/** Source of the top-level declaration that binds `name`, without any `export` keyword. */
+export function declarationSource(tree, name) {
+    const unit = collectDeclarationUnits(tree).units.get(name);
+    return unit === undefined ? undefined : serializeDeclaration(unit.program, unit.declaration);
+}
+/** Names an export statement's source declares, destructured patterns included. */
+export function statementSourceNames(source) {
+    const names = new Set();
+    for (const node of getAST(source).children) {
+        if (!isMdxJsEsm(node) || !estreeIsProgram(node))
+            continue;
+        for (const statement of node.data.estree.body) {
+            for (const name of statementDeclaredNames(statement))
+                names.add(name);
+        }
+    }
+    return names;
+}
+/**
+ * Rewrites a single variable export so it no longer declares the names in `drop`. A declarator
+ * that only binds dropped names and that no kept declarator reads is removed, so its initializer
+ * never runs. Any other dropped name is renamed to a private name throughout the statement, so
+ * rest elements still receive the same keys and kept declarators still read the snippet's values.
+ */
+export function pruneDeclaredNames(source, drop, isNameTaken = () => false) {
+    var _a;
+    const tree = getAST(source);
+    const [node] = tree.children;
+    if (node === undefined || !isMdxJsEsm(node) || !estreeIsProgram(node))
+        return undefined;
+    const program = node.data.estree;
+    const [statement] = program.body;
+    if (program.body.length !== 1 ||
+        (statement === null || statement === void 0 ? void 0 : statement.type) !== 'ExportNamedDeclaration' ||
+        ((_a = statement.declaration) === null || _a === void 0 ? void 0 : _a.type) !== 'VariableDeclaration') {
+        return undefined;
+    }
+    const declaration = statement.declaration;
+    let declarators = [...declaration.declarations];
+    const isRemovable = (declarator) => {
+        const names = new Set();
+        collectPatternNames(declarator.id, names);
+        if (names.size === 0 || ![...names].every((name) => drop.has(name)))
+            return false;
+        const readByOthers = declarators
+            .filter((other) => other !== declarator)
+            .some((other) => [...collectFreeReferences(other)].some((reference) => names.has(reference)));
+        return !readByOthers;
+    };
+    for (let removable = declarators.find(isRemovable); removable !== undefined;) {
+        declarators = declarators.filter((declarator) => declarator !== removable);
+        removable = declarators.find(isRemovable);
+    }
+    if (declarators.length === 0)
+        return undefined;
+    declaration.declarations = declarators;
+    const fingerprint = moduleFingerprint(tree);
+    const renames = new Map();
+    for (const name of drop) {
+        const base = `${PRIVATE_SIBLING_PREFIX}${name}_${fingerprint}`;
+        let candidate = base;
+        for (let suffix = 1; isNameTaken(candidate); suffix++)
+            candidate = `${base}_${suffix}`;
+        renames.set(name, candidate);
+    }
+    renameModuleBindings(declaration, renames, true);
+    return toJs(program, { handlers: jsx }).value;
+}
+const PRIVATE_SIBLING_PREFIX = '__snippet_';
+export function isPrivateSiblingName(name) {
+    return name.startsWith(PRIVATE_SIBLING_PREFIX);
+}
+/** FNV-1a over a module's ESM source, so a helper's private name identifies its exact code. */
+function moduleFingerprint(tree) {
+    let hash = 0x811c9dc5;
+    for (const node of tree.children) {
+        if (!isMdxJsEsm(node))
+            continue;
+        for (let index = 0; index < node.value.length; index++) {
+            hash = Math.imul(hash ^ node.value.charCodeAt(index), 0x01000193) >>> 0;
+        }
+    }
+    return hash.toString(36);
+}
+/**
+ * Removes the private sibling declarations for `names` from the tree, with the private siblings
+ * they reference, and returns them dependencies first so they can be re-inserted above new readers.
+ */
+export function takePrivateDeclarations(tree, names) {
+    const initializedNames = collectInitializedBindingNames(tree);
+    const sourceOrder = new Map(tree.children.map((child, index) => [child, index]));
+    const taken = [];
+    const movable = new Map();
+    // A helper that reads a page binding while initializing stays below it, as does anything that
+    // reads such a helper while initializing. Imports and function declarations are hoisted.
+    const take = (name) => {
+        const known = movable.get(name);
+        if (known !== undefined)
+            return known;
+        movable.set(name, true);
+        const node = tree.children.find((child) => isMdxJsEsm(child) &&
+            estreeIsProgram(child) &&
+            child.data.estree.body.some((statement) => statementDeclaredNames(statement).has(name)));
+        if (node === undefined || !isMdxJsEsm(node) || !estreeIsProgram(node))
+            return true;
+        const eager = collectFreeReferences(node.data.estree, true);
+        let canMove = ![...eager].some((reference) => !isPrivateSiblingName(reference) && initializedNames.has(reference));
+        for (const reference of collectFreeReferences(node.data.estree)) {
+            if (isPrivateSiblingName(reference) && !take(reference) && eager.has(reference)) {
+                canMove = false;
+            }
+        }
+        movable.set(name, canMove);
+        if (!canMove)
+            return false;
+        // A grouped declaration may already have been taken through one of its other names
+        const index = tree.children.indexOf(node);
+        if (index === -1)
+            return true;
+        tree.children.splice(index, 1);
+        const declared = new Set(node.data.estree.body.flatMap((statement) => [...statementDeclaredNames(statement)]));
+        taken.push({ node, declared, eager });
+        return true;
+    };
+    for (const name of names)
+        take(name);
+    // Method and function bodies read lazily, so only reads made while initializing set the order
+    taken.sort((a, b) => { var _a, _b; return ((_a = sourceOrder.get(a.node)) !== null && _a !== void 0 ? _a : 0) - ((_b = sourceOrder.get(b.node)) !== null && _b !== void 0 ? _b : 0); });
+    const byName = new Map();
+    for (const entry of taken) {
+        for (const declaredName of entry.declared)
+            byName.set(declaredName, entry);
+    }
+    return orderByDependencies(taken, (entry) => [...entry.eager].flatMap((reference) => {
+        const dependency = byName.get(reference);
+        return dependency === undefined ? [] : [dependency];
+    })).map((entry) => entry.node);
+}
+/**
+ * Injects each node as high as it can go: at the top of the page, or just below the last
+ * declaration it reads while initializing, such as a reused helper that could not move above a
+ * page binding. Placing nodes one at a time keeps helpers that need no such dependency at the top,
+ * above any existing code that reads them.
+ */
+export function injectBelowEagerDependencies(tree, nodes) {
+    var _a;
+    let topIndex = ((_a = tree.children[0]) === null || _a === void 0 ? void 0 : _a.type) === 'yaml' ? 1 : 0;
+    for (const node of nodes) {
+        const eagerReads = isMdxJsEsm(node) && estreeIsProgram(node)
+            ? collectFreeReferences(node.data.estree, true)
+            : new Set();
+        let index = topIndex;
+        tree.children.forEach((child, childIndex) => {
+            if (childIndex < index || !isMdxJsEsm(child) || !estreeIsProgram(child))
+                return;
+            const declaresRead = child.data.estree.body.some((statement) => {
+                const declaration = statement.type === 'ExportNamedDeclaration' ? statement.declaration : statement;
+                if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) !== 'VariableDeclaration' &&
+                    (declaration === null || declaration === void 0 ? void 0 : declaration.type) !== 'ClassDeclaration') {
+                    return false;
+                }
+                return [...statementDeclaredNames(statement)].some((name) => eagerReads.has(name));
+            });
+            if (declaresRead)
+                index = childIndex + 1;
+        });
+        tree.children.splice(index, 0, node);
+        if (index === topIndex)
+            topIndex++;
+    }
+}
+/**
+ * Collects the snippet declarations the injected statement transitively references. They stay
+ * private to the import, as in a real module: each gets a reserved name derived from its snippet,
+ * and dependencies are declared first. A sibling an earlier import already injected is reused and
+ * moved up with its own dependencies, so it stays above every reader.
+ */
+/**
+ * The private names that the other bindings of `binding`'s declarator take on a page, such as
+ * `other` for `export const [binding, other] = …`.
+ */
+export function patternSiblingNames(imported, binding) {
+    var _a;
+    const unit = collectDeclarationUnits(imported).units.get(binding);
+    const fingerprint = moduleFingerprint(imported);
+    const names = new Map();
+    for (const name of (_a = unit === null || unit === void 0 ? void 0 : unit.names) !== null && _a !== void 0 ? _a : []) {
+        if (name !== binding)
+            names.set(name, `${PRIVATE_SIBLING_PREFIX}${name}_${fingerprint}`);
+    }
+    return names;
+}
+export function prepareSnippetSiblings(destination, imported, statement, requested, 
+// Snippet bindings this page already declares, so readers share that binding instead of a copy
+heldBindings = new Map()) {
+    var _a;
+    const { units, aliases } = collectDeclarationUnits(imported);
+    const requestedOriginal = (_a = aliases.get(requested.name)) !== null && _a !== void 0 ? _a : requested.name;
+    const statementNames = collectTopLevelBindingNames(statement);
+    const statementOriginals = new Set([...statementNames].map((name) => (name === requested.localName ? requestedOriginal : name)));
+    const renames = new Map();
+    if (requestedOriginal !== requested.localName && statementNames.has(requested.localName)) {
+        renames.set(requestedOriginal, requested.localName);
+    }
+    const destinationNames = collectTopLevelBindingNames(destination);
+    const fingerprint = moduleFingerprint(imported);
+    const visited = new Set();
+    const ordered = [];
+    const visitName = (name) => {
+        if (statementOriginals.has(name))
+            return;
+        const unit = units.get(name);
+        // A declarator is reused only when the page holds every name it binds. Copying it for one
+        // name would redeclare the others.
+        const unitHeld = unit !== undefined && [...unit.names].every((unitName) => heldBindings.has(unitName));
+        if (unitHeld) {
+            for (const unitName of unit.names) {
+                const held = heldBindings.get(unitName);
+                if (held !== undefined)
+                    renames.set(unitName, held);
+            }
+            return;
+        }
+        if (unit === undefined || visited.has(unit))
+            return;
+        visited.add(unit);
+        for (const unitName of unit.names) {
+            renames.set(unitName, `${PRIVATE_SIBLING_PREFIX}${unitName}_${fingerprint}`);
+        }
+        for (const reference of unit.references)
+            visitName(reference);
+        ordered.push(unit);
+    };
+    const programs = statement.children.flatMap((node) => isMdxJsEsm(node) && estreeIsProgram(node) ? [node.data.estree] : []);
+    const statementReferences = collectFreeReferences(programs);
+    for (const reference of statementReferences)
+        visitName(reference);
+    // MDX only parses lines that start with `import`/`export` as code, so private siblings are
+    // exported under their reserved names rather than declared bare.
+    const render = (unit) => {
+        const declaration = structuredClone(unit.declaration);
+        renameModuleBindings(declaration, renames, true);
+        return getAST(serializeDeclaration(unit.program, {
+            type: 'ExportNamedDeclaration',
+            declaration,
+            specifiers: [],
+            source: null,
+        }));
+    };
+    // Units are settled dependencies first, so each renders with its dependencies' final names. A
+    // name already in the destination is reused only when it declares exactly this code; otherwise
+    // the next suffix is tried, so a page binding or a helper rewritten for another import never
+    // supplies the value, and a later import of the same code finds the suffixed copy again.
+    const reused = [];
+    const injectedUnits = [];
+    for (const unit of ordered) {
+        const bases = new Map([...unit.names].map((unitName) => {
+            var _a;
+            return [
+                unitName,
+                (_a = renames.get(unitName)) !== null && _a !== void 0 ? _a : unitName,
+            ];
+        }));
+        for (let suffix = 0;; suffix++) {
+            const names = [];
+            for (const [unitName, base] of bases) {
+                const name = suffix === 0 ? base : `${base}_${suffix}`;
+                renames.set(unitName, name);
+                names.push(name);
+            }
+            if (names.some((name) => statementNames.has(name)))
+                continue;
+            const rendered = render(unit);
+            const present = names.find((name) => destinationNames.has(name));
+            if (present === undefined) {
+                injectedUnits.push(unit);
+                break;
+            }
+            if (declarationSource(destination, present) === declarationSource(rendered, present)) {
+                reused.push(...names);
+                break;
+            }
+        }
+    }
+    // A sibling that reads the imported statement while initializing must run after it; anything
+    // that eagerly reads such a sibling follows it there
+    const trailingNames = new Set(statementOriginals);
+    const trailingUnits = new Set();
+    for (let grew = true; grew;) {
+        grew = false;
+        for (const unit of injectedUnits) {
+            if (trailingUnits.has(unit))
+                continue;
+            const eager = collectFreeReferences(unit.declaration, true);
+            if (![...eager].some((reference) => trailingNames.has(reference)))
+                continue;
+            trailingUnits.add(unit);
+            for (const unitName of unit.names)
+                trailingNames.add(unitName);
+            grew = true;
+        }
+    }
+    // Rendered once every name is settled, so cyclic helpers agree on each other's final names
+    const renderAll = (units) => units.flatMap((unit) => render(unit).children);
+    const declarationOrder = orderByEagerReads(injectedUnits, units);
+    const siblings = [
+        ...takePrivateDeclarations(destination, reused),
+        ...renderAll(declarationOrder.filter((unit) => !trailingUnits.has(unit))),
+    ];
+    const trailing = renderAll(declarationOrder.filter((unit) => trailingUnits.has(unit)));
+    const privateNames = new Map();
+    for (const unit of ordered) {
+        for (const unitName of unit.names) {
+            const finalName = renames.get(unitName);
+            if (finalName !== undefined)
+                privateNames.set(unitName, finalName);
+        }
+    }
+    if (![...statementReferences].some((reference) => renames.has(reference))) {
+        return { siblings, statement, trailing, privateNames };
+    }
+    const rewritten = programs.map((program) => {
+        const clone = structuredClone(program);
+        renameModuleBindings(clone, renames, false);
+        return toJs(clone, { handlers: jsx }).value;
+    });
+    return { siblings, statement: getAST(rewritten.join('\n')), trailing, privateNames };
+}