@mintlify/common 1.0.1221 → 1.0.1223

package/dist/mdx/islands/island-placement.js

@@ -0,0 +1,229 @@
+import { walk } from 'estree-walker';
+const BLOCK_PARENTS = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr', 'colgroup', 'svg']);
+const SVG_HTML_POINTS = new Set(['foreignObject', 'desc', 'title']);
+const OPAQUE_PARENTS = new Set(['head', 'script']);
+export const isItemLoose = (item) => item.spread === null || item.spread === undefined ? item.children.length > 1 : item.spread;
+export const isListLoose = (list) => Boolean(list.spread) || list.children.some(isItemLoose);
+export const isIntrinsic = (name) => /^[a-z]/.test(name) && !name.includes('.');
+const blockerInside = (name, blocker) => {
+    if (name === 'p')
+        return 'p';
+    if (!name || !isIntrinsic(name) || blocker === 'p' || blocker === 'paragraph')
+        return blocker;
+    if (blocker && OPAQUE_PARENTS.has(blocker))
+        return blocker;
+    if (OPAQUE_PARENTS.has(name))
+        return name;
+    if (blocker === 'svg')
+        return SVG_HTML_POINTS.has(name) ? false : blocker;
+    if (BLOCK_PARENTS.has(name))
+        return name;
+    return name === 'form' ? blocker : false;
+};
+const jsxNameOf = (name) => {
+    if (name.type === 'JSXIdentifier')
+        return name.name;
+    if (name.type === 'JSXNamespacedName')
+        return `${name.namespace.name}:${name.name.name}`;
+    return `${jsxNameOf(name.object)}.${name.property.name}`;
+};
+const isFunction = (node) => node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression';
+const propertyName = (node, computed) => {
+    if (!computed && node.type === 'Identifier')
+        return node.name;
+    if (node.type === 'Literal' && typeof node.value === 'string')
+        return node.value;
+    return undefined;
+};
+const bindPattern = (pattern, origin, scope) => {
+    if (pattern.type === 'Identifier') {
+        scope.set(pattern.name, origin);
+    }
+    else if (pattern.type === 'AssignmentPattern') {
+        bindPattern(pattern.left, origin, scope);
+    }
+    else if (pattern.type === 'RestElement') {
+        bindPattern(pattern.argument, origin, scope);
+    }
+    else if (pattern.type === 'ArrayPattern') {
+        for (const item of pattern.elements)
+            if (item)
+                bindPattern(item, false, scope);
+    }
+    else if (pattern.type === 'ObjectPattern') {
+        const hasChildren = pattern.properties.some((property) => property.type === 'Property' && propertyName(property.key, property.computed) === 'children');
+        for (const property of pattern.properties) {
+            if (property.type === 'RestElement') {
+                bindPattern(property.argument, origin === 'props' && !hasChildren ? 'props' : false, scope);
+            }
+            else {
+                const childOrigin = origin === 'props' && propertyName(property.key, property.computed) === 'children'
+                    ? 'children'
+                    : false;
+                bindPattern(property.value, childOrigin, scope);
+            }
+        }
+    }
+};
+const bindingOrigin = (name, scopes) => {
+    var _a;
+    for (let index = scopes.length - 1; index >= 0; index--) {
+        const scope = scopes[index];
+        if (scope === null || scope === void 0 ? void 0 : scope.has(name))
+            return (_a = scope.get(name)) !== null && _a !== void 0 ? _a : false;
+    }
+    return false;
+};
+const expressionOrigin = (node, scopes) => {
+    if ((node === null || node === void 0 ? void 0 : node.type) === 'Identifier')
+        return bindingOrigin(node.name, scopes);
+    if ((node === null || node === void 0 ? void 0 : node.type) === 'ChainExpression')
+        return expressionOrigin(node.expression, scopes);
+    if ((node === null || node === void 0 ? void 0 : node.type) === 'MemberExpression' &&
+        expressionOrigin(node.object, scopes) === 'props' &&
+        propertyName(node.property, node.computed) === 'children') {
+        return 'children';
+    }
+    return false;
+};
+const blockScope = (node) => {
+    const scope = new Map();
+    for (const statement of node.body) {
+        if (statement.type === 'VariableDeclaration') {
+            for (const declaration of statement.declarations)
+                bindPattern(declaration.id, false, scope);
+        }
+        else if ((statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration') &&
+            statement.id) {
+            scope.set(statement.id.name, false);
+        }
+    }
+    return scope;
+};
+const forwardsSpreadChildren = (element, attribute) => {
+    if (element.children.some((child) => child.type !== 'JSXText' || child.value.trim().length > 0)) {
+        return false;
+    }
+    const attributes = element.openingElement.attributes;
+    const index = attributes.indexOf(attribute);
+    return !attributes
+        .slice(index + 1)
+        .some((later) => later.type === 'JSXAttribute' && later.name.name === 'children');
+};
+const placementsIn = (component) => {
+    const scopes = [];
+    const open = [];
+    const elements = [];
+    const rendering = [];
+    const found = [];
+    walk(component, {
+        enter(node, parent, key) {
+            if (isFunction(node)) {
+                if (node !== component && open.length === 0) {
+                    this.skip();
+                    return;
+                }
+                const scope = new Map();
+                for (const [index, parameter] of node.params.entries()) {
+                    bindPattern(parameter, node === component && index === 0 ? 'props' : false, scope);
+                }
+                scopes.push(scope);
+            }
+            else if (node.type === 'BlockStatement') {
+                scopes.push(blockScope(node));
+            }
+            else if (node.type === 'CatchClause') {
+                const scope = new Map();
+                if (node.param)
+                    bindPattern(node.param, false, scope);
+                scopes.push(scope);
+            }
+            else if (node.type === 'VariableDeclarator') {
+                const scope = scopes.at(-1);
+                if (scope)
+                    bindPattern(node.id, expressionOrigin(node.init, scopes), scope);
+            }
+            else if (node.type === 'JSXElement') {
+                open.push(jsxNameOf(node.openingElement.name));
+                elements.push(node);
+            }
+            else if (node.type === 'JSXFragment') {
+                open.push(null);
+                elements.push(null);
+            }
+            else if (node.type === 'JSXExpressionContainer') {
+                rendering.push((parent === null || parent === void 0 ? void 0 : parent.type) === 'JSXElement' ||
+                    (parent === null || parent === void 0 ? void 0 : parent.type) === 'JSXFragment' ||
+                    ((parent === null || parent === void 0 ? void 0 : parent.type) === 'JSXAttribute' && parent.name.name === 'children'));
+            }
+            else if (node.type === 'JSXSpreadAttribute') {
+                const element = elements.at(-1);
+                if (element &&
+                    expressionOrigin(node.argument, scopes) === 'props' &&
+                    forwardsSpreadChildren(element, node)) {
+                    found.push([...open]);
+                }
+            }
+            else if (rendering.at(-1) &&
+                open.length > 0 &&
+                expressionOrigin(node, scopes) === 'children' &&
+                !((parent === null || parent === void 0 ? void 0 : parent.type) === 'Property' && key === 'key' && !parent.computed) &&
+                !((parent === null || parent === void 0 ? void 0 : parent.type) === 'MemberExpression' && key === 'property' && !parent.computed)) {
+                found.push([...open]);
+            }
+        },
+        leave(node) {
+            if (isFunction(node) || node.type === 'BlockStatement' || node.type === 'CatchClause') {
+                scopes.pop();
+            }
+            else if (node.type === 'JSXElement' || node.type === 'JSXFragment') {
+                open.pop();
+                elements.pop();
+            }
+            else if (node.type === 'JSXExpressionContainer') {
+                rendering.pop();
+            }
+        },
+    });
+    return found;
+};
+export const childrenPlacements = (statements) => {
+    const placements = new Map();
+    for (const { statement } of statements) {
+        if (statement.type !== 'ExportNamedDeclaration')
+            continue;
+        const declaration = statement.declaration;
+        if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'FunctionDeclaration' && declaration.id) {
+            const found = placementsIn(declaration);
+            if (found.length > 0)
+                placements.set(declaration.id.name, found);
+        }
+        else if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) === 'VariableDeclaration') {
+            for (const declarator of declaration.declarations) {
+                if (declarator.id.type !== 'Identifier' ||
+                    !declarator.init ||
+                    !isFunction(declarator.init)) {
+                    continue;
+                }
+                const found = placementsIn(declarator.init);
+                if (found.length > 0)
+                    placements.set(declarator.id.name, found);
+            }
+        }
+    }
+    return placements;
+};
+export const blockerWithin = (name, blocker, placements, seen = new Set()) => {
+    var _a;
+    if (name === null || isIntrinsic(name))
+        return blockerInside(name, blocker);
+    const inner = new Set([...seen, name]);
+    for (const path of seen.has(name) ? [] : ((_a = placements.get(name)) !== null && _a !== void 0 ? _a : [])) {
+        const inside = path.reduce((current, element) => blockerWithin(element, current, placements, inner), blocker);
+        if (inside)
+            return inside;
+    }
+    return blocker;
+};

package/dist/mdx/islands/packageImports.d.ts

@@ -0,0 +1,28 @@
+import type { Root } from 'mdast';
+import type { MdxjsEsm } from 'mdast-util-mdx';
+import { type ImportSpecifier } from '../../types/mdx/snippets/import.js';
+export { isIdentifierName } from '../snippets/importedExportName.js';
+export declare const MINT_ISLAND_COMPONENT = "_MintIsland";
+export type PackageImportOptions = {
+    packageNames: ReadonlySet<string>;
+    packageSnippets?: ReadonlySet<string>;
+};
+export declare const isDeclaredPackageImport: (source: string, packageNames: ReadonlySet<string>) => boolean;
+export declare const isNonHostBareImport: (source: string) => boolean;
+export declare const importingFile: (node: MdxjsEsm, pagePath: string) => string;
+export declare const isPackageSnippetPath: (path: string) => boolean;
+export declare const isPackageSnippet: (filename: string, importSources: string[]) => boolean;
+export declare const findPackageSnippets: (snippets: {
+    filename: string;
+    tree: Root;
+}[]) => Set<string>;
+export type ImportConflict = {
+    local: string;
+    first: string;
+    second: string;
+};
+export declare const mergeImports: (imports: [string, ImportSpecifier[]][]) => {
+    imports: [string, ImportSpecifier[]][];
+    conflicts: ImportConflict[];
+};
+export declare const createImportNode: (imports: [string, ImportSpecifier[]][]) => MdxjsEsm;

package/dist/mdx/islands/packageImports.js

@@ -0,0 +1,155 @@
+import { jsx, toJs } from 'estree-util-to-js';
+import { MdxImportSpecifier } from '../../types/mdx/snippets/import.js';
+import { injectedSnippetFile } from '../plugins/remark/remarkMdxInjectSnippets.js';
+import { isIdentifierName } from '../snippets/importedExportName.js';
+import { getSpecifierPackageName, isBareSpecifier, isHostProvidedSpecifier, } from '../snippets/isBareSpecifier.js';
+import { isJsxOrTsx } from '../snippets/isJsxOrTsx.js';
+import { resolveImportPath } from '../snippets/resolveImportPath.js';
+import { isMdxJsEsm } from '../utils.js';
+export { isIdentifierName } from '../snippets/importedExportName.js';
+export const MINT_ISLAND_COMPONENT = '_MintIsland';
+const identifier = (name) => ({ type: 'Identifier', name });
+const printedExportName = (name) => identifier(isIdentifierName(name) ? name : JSON.stringify(name));
+const exportName = (name) => isIdentifierName(name)
+    ? identifier(name)
+    : { type: 'Literal', value: name };
+export const isDeclaredPackageImport = (source, packageNames) => {
+    if (!isBareSpecifier(source) || isHostProvidedSpecifier(source))
+        return false;
+    const packageName = getSpecifierPackageName(source);
+    return packageName !== undefined && packageNames.has(packageName);
+};
+export const isNonHostBareImport = (source) => isBareSpecifier(source) && !isHostProvidedSpecifier(source);
+export const importingFile = (node, pagePath) => {
+    const file = injectedSnippetFile(node);
+    return file === undefined ? pagePath : `/_snippets/${file}`;
+};
+export const isPackageSnippetPath = (path) => {
+    const normalized = path.startsWith('/') ? path : `/${path}`;
+    return normalized.startsWith('/snippets/') && isJsxOrTsx(normalized);
+};
+export const isPackageSnippet = (filename, importSources) => isPackageSnippetPath(filename) && importSources.some(isNonHostBareImport);
+const moduleSources = (tree) => {
+    var _a, _b, _c, _d;
+    const sources = [];
+    for (const node of tree.children) {
+        if (!isMdxJsEsm(node))
+            continue;
+        for (const statement of (_c = (_b = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree) === null || _b === void 0 ? void 0 : _b.body) !== null && _c !== void 0 ? _c : []) {
+            if (statement.type !== 'ImportDeclaration' &&
+                statement.type !== 'ExportNamedDeclaration' &&
+                statement.type !== 'ExportAllDeclaration') {
+                continue;
+            }
+            const source = (_d = statement.source) === null || _d === void 0 ? void 0 : _d.value;
+            if (typeof source === 'string')
+                sources.push(source);
+        }
+    }
+    return sources;
+};
+export const findPackageSnippets = (snippets) => {
+    const candidates = new Map();
+    for (const { filename, tree } of snippets) {
+        const path = filename.startsWith('/') ? filename : `/${filename}`;
+        if (isPackageSnippetPath(path))
+            candidates.set(path, moduleSources(tree));
+    }
+    const found = new Set();
+    let grew = true;
+    while (grew) {
+        grew = false;
+        for (const [path, sources] of candidates) {
+            if (found.has(path))
+                continue;
+            const usesPackages = sources.some((source) => { var _a; return isNonHostBareImport(source) || found.has((_a = resolveImportPath(source, path)) !== null && _a !== void 0 ? _a : ''); });
+            if (usesPackages) {
+                found.add(path);
+                grew = true;
+            }
+        }
+    }
+    return found;
+};
+const importedBinding = (specifier) => {
+    if (specifier.type === MdxImportSpecifier.ImportNamespaceSpecifier)
+        return null;
+    if (specifier.type === MdxImportSpecifier.ImportDefaultSpecifier)
+        return 'default';
+    return specifier.name;
+};
+const describeBinding = (source, imported) => {
+    const name = imported === null ? '*' : isIdentifierName(imported) ? imported : JSON.stringify(imported);
+    return `${name} from "${source}"`;
+};
+export const mergeImports = (imports) => {
+    var _a, _b;
+    const merged = new Map();
+    const bound = new Map();
+    const seen = new Set();
+    const conflicts = [];
+    for (const [source, specifiers] of imports) {
+        if (specifiers.length === 0 && !merged.has(source))
+            merged.set(source, []);
+        for (const specifier of specifiers) {
+            const local = (_a = specifier.renamedName) !== null && _a !== void 0 ? _a : specifier.name;
+            const imported = importedBinding(specifier);
+            const key = JSON.stringify([local, source, imported]);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const binding = describeBinding(source, imported);
+            const first = bound.get(local);
+            if (first === undefined)
+                bound.set(local, binding);
+            else
+                conflicts.push({ local, first, second: binding });
+            merged.set(source, [...((_b = merged.get(source)) !== null && _b !== void 0 ? _b : []), specifier]);
+        }
+    }
+    return { imports: [...merged], conflicts };
+};
+const importDeclarations = (source, specifiers, imported) => {
+    var _a;
+    const declaration = (entries) => ({
+        type: 'ImportDeclaration',
+        specifiers: entries,
+        source: { type: 'Literal', value: source },
+    });
+    const main = [];
+    const separate = [];
+    for (const specifier of specifiers) {
+        switch (specifier.type) {
+            case MdxImportSpecifier.ImportDefaultSpecifier:
+                if (main.some((entry) => entry.type === 'ImportDefaultSpecifier')) {
+                    separate.push(declaration([{ type: 'ImportDefaultSpecifier', local: identifier(specifier.name) }]));
+                }
+                else {
+                    main.unshift({ type: 'ImportDefaultSpecifier', local: identifier(specifier.name) });
+                }
+                break;
+            case MdxImportSpecifier.ImportNamespaceSpecifier:
+                separate.push(declaration([{ type: 'ImportNamespaceSpecifier', local: identifier(specifier.name) }]));
+                break;
+            default:
+                main.push({
+                    type: 'ImportSpecifier',
+                    imported: imported(specifier.name),
+                    local: identifier((_a = specifier.renamedName) !== null && _a !== void 0 ? _a : specifier.name),
+                });
+        }
+    }
+    return [...(main.length > 0 || specifiers.length === 0 ? [declaration(main)] : []), ...separate];
+};
+export const createImportNode = (imports) => {
+    const program = (imported) => ({
+        type: 'Program',
+        sourceType: 'module',
+        body: imports.flatMap(([source, specifiers]) => importDeclarations(source, specifiers, imported)),
+    });
+    return {
+        type: 'mdxjsEsm',
+        value: toJs(program(printedExportName), { handlers: jsx }).value.trim(),
+        data: { estree: program(exportName) },
+    };
+};

package/dist/mdx/islands/remarkPackageIslands.d.ts

@@ -0,0 +1,23 @@
+import type { Root } from 'mdast';
+import type { MdxExtracts, MdxIslandExtract } from '../../types/mdx/MdxExtracts.js';
+import type { ExtractPackageIslandsOptions, ExtractPackageIslandsResult, IslandError } from './types.js';
+export type RemarkPackageIslandsOptions = ExtractPackageIslandsOptions & {
+    plan?: ExtractPackageIslandsResult;
+    islandHtml?: Record<string, MdxIslandExtract>;
+    baseUrl?: string;
+    mdxExtracts?: MdxExtracts;
+};
+export declare class PackageIslandsError extends Error {
+    readonly pagePath: string;
+    readonly errors: IslandError[];
+    constructor(pagePath: string, errors: IslandError[]);
+}
+export declare const islandPrefixFor: (id: string) => string;
+export declare const preprocessPageContent: (content: string, variables?: Record<string, string>) => string;
+export declare const parsePackageIslands: (processedContent: string, options: ExtractPackageIslandsOptions, snippetTreeMap?: Record<string, Root>) => ExtractPackageIslandsResult;
+export declare const getPackageIslandsForContent: ({ content, variables, snippetTreeMap, ...options }: ExtractPackageIslandsOptions & {
+    content: string;
+    variables?: Record<string, string>;
+    snippetTreeMap?: Record<string, Root>;
+}) => ExtractPackageIslandsResult;
+export declare const remarkPackageIslands: (options: RemarkPackageIslandsOptions) => (tree: Root) => void;

package/dist/mdx/islands/remarkPackageIslands.js

@@ -0,0 +1,177 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx, toJs } from 'estree-util-to-js';
+import { SKIP, visit } from 'unist-util-visit';
+import { VFile } from 'vfile';
+import { findSnippetCycle, remarkMdxInjectSnippets, } from '../plugins/remark/remarkMdxInjectSnippets.js';
+import { preprocessCustomHeadingIds } from '../preprocessCustomHeadingIds.js';
+import { preprocessMdxFragmentCode } from '../preprocessMdxFragmentCode.js';
+import { coreRemark } from '../remark.js';
+import { replaceVariables } from '../replaceVariables.js';
+import { resolveImportPath } from '../snippets/resolveImportPath.js';
+import { extractPackageIslands, soleParagraphChild } from './extractPackageIslands.js';
+import { MINT_ISLAND_COMPONENT, importingFile, isDeclaredPackageImport, isPackageSnippetPath, } from './packageImports.js';
+export class PackageIslandsError extends Error {
+    constructor(pagePath, errors) {
+        super([
+            `Package components in ${pagePath} can't be built:`,
+            ...errors.map(({ line, message }) => `  ${line === undefined ? '' : `line ${line}: `}${message}`),
+        ].join('\n'));
+        this.pagePath = pagePath;
+        this.errors = errors;
+        this.name = 'PackageIslandsError';
+    }
+}
+export const islandPrefixFor = (id) => `mi-${id}-`;
+export const preprocessPageContent = (content, variables) => preprocessCustomHeadingIds(preprocessMdxFragmentCode(replaceVariables(content, variables)));
+export const parsePackageIslands = (processedContent, options, snippetTreeMap) => {
+    const tree = coreRemark().parse(processedContent);
+    if (snippetTreeMap) {
+        const cycle = findSnippetCycle(tree, snippetTreeMap);
+        if (cycle) {
+            const message = `<Snippet file="${cycle[0]}"> includes itself (${cycle.join(' -> ')}).`;
+            return { islands: [], roots: [], errors: [{ message }] };
+        }
+        remarkMdxInjectSnippets(snippetTreeMap)(tree, new VFile());
+    }
+    return extractPackageIslands(tree, options);
+};
+export const getPackageIslandsForContent = (_a) => {
+    var { content, variables, snippetTreeMap } = _a, options = __rest(_a, ["content", "variables", "snippetTreeMap"]);
+    return parsePackageIslands(preprocessPageContent(content, variables), options, snippetTreeMap);
+};
+const placeholder = (type, id) => ({
+    type,
+    name: MINT_ISLAND_COMPONENT,
+    attributes: [{ type: 'mdxJsxAttribute', name: 'id', value: id }],
+    children: [],
+});
+const isIslandImport = (source, importer, options) => {
+    if (isDeclaredPackageImport(source, options.packageNames))
+        return true;
+    const resolved = resolveImportPath(source, importer);
+    if (resolved === null)
+        return false;
+    return options.packageSnippets
+        ? options.packageSnippets.has(resolved)
+        : isPackageSnippetPath(resolved);
+};
+const removeIslandImports = (tree, options) => {
+    const emptied = new Set();
+    visit(tree, 'mdxjsEsm', (node) => {
+        var _a;
+        const program = (_a = node.data) === null || _a === void 0 ? void 0 : _a.estree;
+        if (!program)
+            return;
+        const importer = importingFile(node, options.pagePath);
+        const body = program.body.filter((statement) => statement.type !== 'ImportDeclaration' ||
+            typeof statement.source.value !== 'string' ||
+            !isIslandImport(statement.source.value, importer, options));
+        if (body.length === program.body.length)
+            return;
+        if (body.length === 0) {
+            emptied.add(node);
+            return;
+        }
+        program.body = body;
+        node.value = toJs(program, { handlers: jsx }).value;
+    });
+    if (emptied.size === 0)
+        return;
+    visit(tree, (node, index, parent) => {
+        if (parent && index !== undefined && emptied.has(node)) {
+            parent.children.splice(index, 1);
+            return [SKIP, index];
+        }
+    });
+};
+export const remarkPackageIslands = (options) => (tree) => {
+    var _a, _b, _c;
+    const own = extractPackageIslands(tree, options);
+    const plan = (_a = options.plan) !== null && _a !== void 0 ? _a : own;
+    if (plan.errors.length > 0)
+        throw new PackageIslandsError(options.pagePath, plan.errors);
+    if (own.errors.length > 0)
+        throw new PackageIslandsError(options.pagePath, own.errors);
+    if (own.roots.length !== plan.roots.length ||
+        own.roots.some((root, index) => { var _a; return root.name !== ((_a = plan.roots[index]) === null || _a === void 0 ? void 0 : _a.name); })) {
+        throw new PackageIslandsError(options.pagePath, [
+            { message: 'Package components found at compile time differ from the extracted islands.' },
+        ]);
+    }
+    if (own.roots.length === 0)
+        return;
+    const ids = new Map();
+    const buildErrors = [];
+    own.roots.forEach((root, index) => {
+        var _a, _b, _c, _d, _e;
+        const id = (_b = (_a = plan.roots[index]) === null || _a === void 0 ? void 0 : _a.id) !== null && _b !== void 0 ? _b : root.id;
+        ids.set(root.node, id);
+        if (!options.islandHtml)
+            return;
+        const entry = options.islandHtml[id];
+        if (entry === undefined) {
+            buildErrors.push({
+                line: (_c = root.node.position) === null || _c === void 0 ? void 0 : _c.start.line,
+                message: `<${root.name}> compiles to island ${id}, which isn't in the package build.`,
+            });
+            return;
+        }
+        if (entry.prefix !== islandPrefixFor(id)) {
+            buildErrors.push({
+                line: (_d = root.node.position) === null || _d === void 0 ? void 0 : _d.start.line,
+                message: `Island ${id} must use the prefix ${islandPrefixFor(id)}.`,
+            });
+        }
+        if (entry.html !== undefined && typeof entry.html !== 'string') {
+            buildErrors.push({
+                line: (_e = root.node.position) === null || _e === void 0 ? void 0 : _e.start.line,
+                message: `Island ${id} HTML must be a string.`,
+            });
+        }
+    });
+    if (buildErrors.length > 0)
+        throw new PackageIslandsError(options.pagePath, buildErrors);
+    visit(tree, (node, index, parent) => {
+        if (!parent || index === undefined)
+            return;
+        if (node.type === 'paragraph') {
+            const only = soleParagraphChild(node);
+            const id = only ? ids.get(only) : undefined;
+            if (id === undefined)
+                return;
+            parent.children[index] = placeholder('mdxJsxFlowElement', id);
+            return SKIP;
+        }
+        const id = ids.get(node);
+        if (id === undefined)
+            return;
+        parent.children[index] =
+            node.type === 'mdxJsxTextElement'
+                ? placeholder('mdxJsxTextElement', id)
+                : placeholder('mdxJsxFlowElement', id);
+        return SKIP;
+    });
+    removeIslandImports(tree, options);
+    if (!options.mdxExtracts)
+        return;
+    const islands = {};
+    for (const id of ids.values()) {
+        if (id in islands)
+            continue;
+        const entry = (_b = options.islandHtml) === null || _b === void 0 ? void 0 : _b[id];
+        islands[id] = Object.assign(Object.assign({}, ((entry === null || entry === void 0 ? void 0 : entry.html) !== undefined && { html: entry.html })), { prefix: (_c = entry === null || entry === void 0 ? void 0 : entry.prefix) !== null && _c !== void 0 ? _c : islandPrefixFor(id) });
+    }
+    options.mdxExtracts.islands = islands;
+    if (options.baseUrl !== undefined)
+        options.mdxExtracts.packageBaseUrl = options.baseUrl;
+};

package/dist/mdx/islands/sha256.d.ts

@@ -0,0 +1 @@
+export declare const sha256Hex: (input: string) => string;