@mintlify/common 1.0.1221 → 1.0.1223

package/dist/colors.d.ts

@@ -52,6 +52,10 @@ export declare const generateDynamicGrayScale: (primaryColor: string) => Tailwin
  * "255 0 128", the function will return "255, 0, 128".
  */
 export declare const convertColorsToRgbWithCommas: (color: string) => string;
+export declare const getDefaultBackgroundColors: (primaryLight?: string) => {
+    light: string;
+    dark: string;
+};
 export declare function getBackgroundColors(docsConfig?: DocsConfig): {
     light: string;
     dark: string;

package/dist/colors.js

@@ -98,10 +98,15 @@ export const generateDynamicGrayScale = (primaryColor) => {
 export const convertColorsToRgbWithCommas = (color) => {
     return color.split(' ').join(', ');
 };
+const DEFAULT_PRIMARY_LIGHT = '#4ADE80';
+export const getDefaultBackgroundColors = (primaryLight = DEFAULT_PRIMARY_LIGHT) => ({
+    light: '#ffffff',
+    dark: generateDynamicBackgroundDarkColor(primaryLight, undefined, true),
+});
 export function getBackgroundColors(docsConfig) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
     const primaryColor = (docsConfig === null || docsConfig === void 0 ? void 0 : docsConfig.colors.primary) || '#16A34A';
-    const primaryLight = (_a = docsConfig === null || docsConfig === void 0 ? void 0 : docsConfig.colors.light) !== null && _a !== void 0 ? _a : '#4ADE80';
+    const primaryLight = (_a = docsConfig === null || docsConfig === void 0 ? void 0 : docsConfig.colors.light) !== null && _a !== void 0 ? _a : DEFAULT_PRIMARY_LIGHT;
     if ((docsConfig === null || docsConfig === void 0 ? void 0 : docsConfig.theme) === 'linden') {
         docsConfig.background = Object.assign(Object.assign({}, docsConfig.background), { color: {
                 light: ((_c = (_b = docsConfig.background) === null || _b === void 0 ? void 0 : _b.color) === null || _c === void 0 ? void 0 : _c.light) ||

package/dist/mdx/getMDXOptions.d.ts

@@ -4,6 +4,7 @@ import { DocsConfig } from '@mintlify/validation';
 import type { Root } from 'mdast';
 import type { PluggableList } from 'unified';
 import { MdxExtracts } from '../types/mdx/MdxExtracts.js';
+import { type RemarkPackageIslandsOptions } from './islands/remarkPackageIslands.js';
 import { type MdxJsDetection } from './plugins/remark/remarkMdxRemoveJs.js';
 type MDXOptionsData = {
     snippetTreeMap: Record<string, Root>;
@@ -13,7 +14,7 @@ type MDXOptionsData = {
     tailwindSelectors?: string[];
     path?: string;
 };
-export declare const getMDXOptions: ({ data, remarkPlugins, earlyRemarkPlugins, rehypePlugins, mdxExtracts, allowedComponents, fragmentPlugins, detectJs, }: {
+export declare const getMDXOptions: ({ data, remarkPlugins, earlyRemarkPlugins, rehypePlugins, mdxExtracts, allowedComponents, fragmentPlugins, packageIslands, detectJs, }: {
     data: MDXOptionsData;
     remarkPlugins?: PluggableList;
     earlyRemarkPlugins?: PluggableList;
@@ -25,6 +26,7 @@ export declare const getMDXOptions: ({ data, remarkPlugins, earlyRemarkPlugins,
         remarkPlugins: PluggableList;
         rehypePlugins: PluggableList;
     };
+    packageIslands?: Omit<RemarkPackageIslandsOptions, "mdxExtracts">;
     detectJs?: MdxJsDetection;
 }) => SerializeOptions["mdxOptions"];
 export {};

package/dist/mdx/getMDXOptions.js

@@ -1,3 +1,4 @@
+import { remarkPackageIslands, } from './islands/remarkPackageIslands.js';
 import { rehypeCodeBlocks, rehypeDynamicTailwindCss, rehypeKeyboardSymbols, rehypeListItemText, rehypeMdxExtractEndpoint, rehypeMdxExtractExamples, rehypeParamFieldIds, rehypeRawComponents, rehypeTable, rehypeUnicodeIds, rehypeZoomImages, remarkExtractChangelogFilters, remarkExtractTableOfContents, remarkFileTree, remarkFrames, remarkComponentIds, remarkMdxInjectSnippets, remarkMdxStyleStringToObject, remarkMdxRemoveUnusedVariables, remarkRemoveImports, remarkMdxExtractPanel, remarkResolveRelativeLinks, remarkVideo, remarkMdxClientComponentBoundaries, remarkExtractMultiView, remarkPrompt, remarkUnwrapInlineJsx, remarkUnwrapJsxHeadings, remarkMapExplicitAnchors, } from './plugins/index.js';
 import { remarkMdxExpandExpressions, } from './plugins/remark/remarkMdxExpandExpressions.js';
 import { remarkMdxDetectJs } from './plugins/remark/remarkMdxRemoveJs.js';
@@ -14,7 +15,7 @@ const rehypeExtractors = (mdxExtracts, data) => {
         [rehypeMdxExtractEndpoint, data.pageMetadata, data.config, mdxExtracts],
     ];
 };
-export const getMDXOptions = ({ data, remarkPlugins = [], earlyRemarkPlugins = [], rehypePlugins = [], mdxExtracts, allowedComponents = [], fragmentPlugins, detectJs, }) => {
+export const getMDXOptions = ({ data, remarkPlugins = [], earlyRemarkPlugins = [], rehypePlugins = [], mdxExtracts, allowedComponents = [], fragmentPlugins, packageIslands, detectJs, }) => {
     // `fragment`: the list is compiling the body of an `<MDX>` inside an expression. Page-level
     // extractors that hoist an element out of the tree (`<Panel>`, `<RequestExample>`,
     // `<ResponseExample>`) are skipped there so the element stays in its branch and renders inline
@@ -26,6 +27,11 @@ export const getMDXOptions = ({ data, remarkPlugins = [], earlyRemarkPlugins = [
         remarkPlugins: [
             // first, so `<Snippet file>` is injected on the page and inside every `<MDX>` fragment
             [remarkMdxInjectSnippets, data.snippetTreeMap],
+            ...(fragment || !packageIslands
+                ? []
+                : [
+                    [remarkPackageIslands, Object.assign(Object.assign({}, packageIslands), { mdxExtracts: extracts })],
+                ]),
             [
                 remarkMdxExpandExpressions,
                 {

package/dist/mdx/index.d.ts

@@ -12,3 +12,4 @@ export * from './getS3ImageUri.js';
 export * from './getCodeStyling.js';
 export * from './replaceVariables.js';
 export * from './componentIds.js';
+export * from './islands/index.js';

package/dist/mdx/index.js

@@ -12,3 +12,4 @@ export * from './getS3ImageUri.js';
 export * from './getCodeStyling.js';
 export * from './replaceVariables.js';
 export * from './componentIds.js';
+export * from './islands/index.js';

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

@@ -0,0 +1,5 @@
+import type { Parent, Root, RootContent } from 'mdast';
+import type { ExtractPackageIslandsOptions, ExtractPackageIslandsResult } from './types.js';
+export declare const islandIdFor: (module: string) => string;
+export declare const soleParagraphChild: (paragraph: Parent) => RootContent | undefined;
+export declare const extractPackageIslands: (tree: Root, options: ExtractPackageIslandsOptions) => ExtractPackageIslandsResult;

package/dist/mdx/islands/extractPackageIslands.js

@@ -0,0 +1,147 @@
+import { bindingHead, collectBindings, collectConsts, esmStatements, lineOf, referencesIn, } from './island-bindings.js';
+import { IslandModuleBuilder, MOVE_TO_SNIPPET } from './island-module-builder.js';
+import { blockerWithin, childrenPlacements, isIntrinsic, isListLoose, } from './island-placement.js';
+import { sha256Hex } from './sha256.js';
+const CSS_SPECIFIER = /\.css(?:[?#].*)?$/;
+export const islandIdFor = (module) => `i${sha256Hex(module).slice(0, 16)}`;
+const withPlacement = (module, placement) => `${module.endsWith('\n') ? module : `${module}\n`}// placement ${placement}\n`;
+export const soleParagraphChild = (paragraph) => {
+    const meaningful = paragraph.children.filter((child) => child.type !== 'text' || child.value.trim() !== '');
+    return meaningful.length === 1 ? meaningful[0] : undefined;
+};
+export const extractPackageIslands = (tree, options) => {
+    const statements = esmStatements(tree, options.pagePath);
+    const { bindings, undeclared, conflicts, sideEffects, order } = collectBindings(statements, options);
+    const islands = new Map();
+    const errors = [...conflicts];
+    const roots = [];
+    const sideEffectErrors = () => {
+        if (errors.length > 0 || roots.length > 0)
+            return [];
+        return [...sideEffects].map(([source, line]) => {
+            const message = CSS_SPECIFIER.test(source)
+                ? `"${source}" is imported on a page without package components, so it never loads. List it in packages.css in docs.json to load it on every page and remove this import, or use a package component on this page.`
+                : `"${source}" is imported on a page without package components, so it never runs. Use a package component on this page or remove this import.`;
+            return { line, code: 'side-effect-import-without-island', message };
+        });
+    };
+    if (bindings.size === 0 && undeclared.size === 0) {
+        return { islands: [], errors: [...errors, ...sideEffectErrors()], roots };
+    }
+    const consts = collectConsts(statements, options);
+    const wrappers = childrenPlacements(statements);
+    const reportReferences = (node, fallbackLine) => {
+        var _a;
+        for (const reference of referencesIn(node, bindings)) {
+            const binding = bindings.get(reference.name);
+            const from = binding ? `"${binding.source}"` : 'a package';
+            errors.push({
+                line: (_a = reference.line) !== null && _a !== void 0 ? _a : fallbackLine,
+                message: reference.jsx
+                    ? `<${reference.name}> (from ${from}) is used inside JavaScript. Package components can only be written as JSX directly in MDX. ${MOVE_TO_SNIPPET}`
+                    : `${reference.name} (from ${from}) is used inside JavaScript. Package components can only be written as JSX directly in MDX. ${MOVE_TO_SNIPPET}`,
+            });
+        }
+    };
+    for (const { statement, line } of statements) {
+        if (statement.type !== 'ImportDeclaration')
+            reportReferences(statement, line);
+    }
+    const tightItems = new WeakSet();
+    const placements = new Map();
+    const visitChildren = (parent, blocker, outside = blocker, via) => {
+        var _a, _b, _c, _d, _e;
+        for (const child of parent.children) {
+            if (child.type === 'mdxJsxFlowElement' || child.type === 'mdxJsxTextElement') {
+                const head = child.name ? bindingHead(child.name) : undefined;
+                const binding = head === undefined ? undefined : bindings.get(head);
+                if (child.name && binding) {
+                    const blocking = parent.type === 'paragraph' && soleParagraphChild(parent) === child ? outside : blocker;
+                    if (blocking) {
+                        let message;
+                        if (blocking === 'paragraph') {
+                            message = `<${child.name}> is inside a line of text. Package components render as a block, so put <${child.name}> on its own line.`;
+                        }
+                        else if (via) {
+                            message = `<${child.name}> is inside <${via}>, which renders it inside a <${blocking}>. Package components render as a block, so move <${child.name}> out of <${via}>.`;
+                        }
+                        else {
+                            message = `<${child.name}> is inside a <${blocking}>. Package components render as a block, so move <${child.name}> out of the <${blocking}>.`;
+                        }
+                        errors.push({ line: lineOf(child), message });
+                        continue;
+                    }
+                    const builder = new IslandModuleBuilder(child.name, options.pagePath, bindings, undeclared, consts, sideEffects, order);
+                    const element = builder.element(child);
+                    if (builder.errors.length > 0 || !element) {
+                        errors.push(...builder.errors);
+                        continue;
+                    }
+                    const base = builder.module(element);
+                    const baseId = islandIdFor(base);
+                    const placement = ((_a = placements.get(baseId)) !== null && _a !== void 0 ? _a : 0) + 1;
+                    placements.set(baseId, placement);
+                    const module = placement === 1 ? base : withPlacement(base, placement);
+                    const id = placement === 1 ? baseId : islandIdFor(module);
+                    if (!islands.has(id)) {
+                        islands.set(id, {
+                            id,
+                            pagePath: options.pagePath,
+                            kind: binding.kind === 'snippet' ? 'snippet' : 'inline',
+                            imports: builder.imports(),
+                            module,
+                        });
+                    }
+                    roots.push({ id, name: child.name, node: child, parent });
+                    continue;
+                }
+                if (child.name && head !== undefined && undeclared.has(head)) {
+                    errors.push({
+                        line: lineOf(child),
+                        message: `<${child.name}> is imported from "${undeclared.get(head)}", which isn't listed in package.json dependencies.`,
+                    });
+                    continue;
+                }
+                for (const attribute of child.attributes) {
+                    let estree;
+                    if (attribute.type === 'mdxJsxExpressionAttribute') {
+                        estree = (_b = attribute.data) === null || _b === void 0 ? void 0 : _b.estree;
+                    }
+                    else if (typeof attribute.value === 'object') {
+                        estree = (_d = (_c = attribute.value) === null || _c === void 0 ? void 0 : _c.data) === null || _d === void 0 ? void 0 : _d.estree;
+                    }
+                    if (estree)
+                        reportReferences(estree, lineOf(child));
+                }
+                const inside = blockerWithin(child.name, blocker, wrappers);
+                let by;
+                if (inside === blocker) {
+                    by = via;
+                }
+                else if (child.name && !isIntrinsic(child.name)) {
+                    by = child.name;
+                }
+                visitChildren(child, inside, inside, by);
+                continue;
+            }
+            if (child.type === 'mdxFlowExpression' || child.type === 'mdxTextExpression') {
+                if ((_e = child.data) === null || _e === void 0 ? void 0 : _e.estree)
+                    reportReferences(child.data.estree, lineOf(child));
+                continue;
+            }
+            if (child.type === 'list' && !isListLoose(child)) {
+                for (const item of child.children)
+                    tightItems.add(item);
+            }
+            if (child.type === 'paragraph') {
+                const rendersP = !(parent.type === 'listItem' && tightItems.has(parent));
+                visitChildren(child, blocker === 'p' || !rendersP ? blocker : 'paragraph', blocker, via);
+                continue;
+            }
+            if ('children' in child)
+                visitChildren(child, blocker, blocker, via);
+        }
+    };
+    visitChildren(tree, false);
+    return { islands: [...islands.values()], errors: [...errors, ...sideEffectErrors()], roots };
+};

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

@@ -0,0 +1,5 @@
+export * from './extractPackageIslands.js';
+export * from './packageImports.js';
+export * from './remarkPackageIslands.js';
+export * from './sha256.js';
+export * from './types.js';

package/dist/mdx/islands/index.js

@@ -0,0 +1,5 @@
+export * from './extractPackageIslands.js';
+export * from './packageImports.js';
+export * from './remarkPackageIslands.js';
+export * from './sha256.js';
+export * from './types.js';

package/dist/mdx/islands/island-bindings.d.ts

@@ -0,0 +1,40 @@
+import type { Node as EstreeNode, Program } from 'estree-jsx';
+import type { Root } from 'mdast';
+import { type ConstEntry } from './static-expressions.js';
+import type { ExtractPackageIslandsOptions, IslandError } from './types.js';
+export type Binding = {
+    local: string;
+    source: string;
+    imported: string;
+    kind: 'package' | 'snippet';
+    invalidName?: boolean;
+};
+export declare const lineOf: (node: {
+    position?: {
+        start: {
+            line: number;
+        };
+    };
+}) => number | undefined;
+type EsmStatement = Program['body'][number];
+export type LocatedStatement = {
+    statement: EsmStatement;
+    line?: number;
+    importer: string;
+};
+export declare const esmStatements: (tree: Root, pagePath: string) => LocatedStatement[];
+export declare const collectBindings: (statements: LocatedStatement[], options: ExtractPackageIslandsOptions) => {
+    bindings: Map<string, Binding>;
+    undeclared: Map<string, string>;
+    conflicts: IslandError[];
+    sideEffects: Map<string, number | undefined>;
+    order: string[];
+};
+export declare const collectConsts: (statements: LocatedStatement[], options: ExtractPackageIslandsOptions) => Map<string, ConstEntry>;
+export declare const bindingHead: (name: string) => string | undefined;
+export declare const referencesIn: (node: EstreeNode, bindings: Map<string, Binding>) => {
+    name: string;
+    jsx: boolean;
+    line?: number;
+}[];
+export {};

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

@@ -0,0 +1,149 @@
+import { walk } from 'estree-walker';
+import { importedExportName, isIdentifierName } from '../snippets/importedExportName.js';
+import { resolveImportPath } from '../snippets/resolveImportPath.js';
+import { isMdxJsEsm } from '../utils.js';
+import { importingFile, isDeclaredPackageImport, isNonHostBareImport, isPackageSnippetPath, } from './packageImports.js';
+import { IDENTIFIER_NAME, toStaticExpression, valueToExpression, } from './static-expressions.js';
+export const lineOf = (node) => { var _a; return (_a = node.position) === null || _a === void 0 ? void 0 : _a.start.line; };
+const importedName = (specifier) => {
+    if (specifier.type === 'ImportDefaultSpecifier')
+        return { imported: 'default' };
+    if (specifier.type === 'ImportNamespaceSpecifier')
+        return { imported: '*' };
+    const imported = importedExportName(specifier);
+    return isIdentifierName(imported) ? { imported } : { imported, invalidName: true };
+};
+export const esmStatements = (tree, pagePath) => {
+    const statements = [];
+    const visitNode = (node) => {
+        var _a, _b, _c, _d, _e;
+        if (isMdxJsEsm(node)) {
+            const importer = importingFile(node, pagePath);
+            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 : []) {
+                statements.push({ statement, line: (_e = (_d = statement.loc) === null || _d === void 0 ? void 0 : _d.start.line) !== null && _e !== void 0 ? _e : lineOf(node), importer });
+            }
+            return;
+        }
+        if ('children' in node)
+            for (const child of node.children)
+                visitNode(child);
+    };
+    visitNode(tree);
+    return statements;
+};
+const describeImport = (imported, source) => `${imported === '*' || isIdentifierName(imported) ? imported : JSON.stringify(imported)} from "${source}"`;
+export const collectBindings = (statements, options) => {
+    const bindings = new Map();
+    const undeclared = new Map();
+    const conflicts = [];
+    const sideEffects = new Map();
+    const order = new Set();
+    const firstImports = new Map();
+    const reported = new Set();
+    const track = (local, described, island, line) => {
+        const first = firstImports.get(local);
+        if (!first) {
+            firstImports.set(local, { described, island });
+            return;
+        }
+        const key = JSON.stringify([local, described]);
+        if (first.described === described || !(first.island || island) || reported.has(key))
+            return;
+        reported.add(key);
+        conflicts.push({
+            line,
+            message: `${local} is imported twice on this page, as ${first.described} and as ${described}. Snippets on a page share its imports, so import one of them under another name.`,
+        });
+    };
+    for (const { statement, importer, line } of statements) {
+        if (statement.type !== 'ImportDeclaration')
+            continue;
+        const source = statement.source.value;
+        if (typeof source !== 'string')
+            continue;
+        const declared = isDeclaredPackageImport(source, options.packageNames);
+        const bare = !declared && isNonHostBareImport(source);
+        const resolved = declared || bare ? null : resolveImportPath(source, importer);
+        const isSnippet = resolved !== null &&
+            (options.packageSnippets
+                ? options.packageSnippets.has(resolved)
+                : isPackageSnippetPath(resolved));
+        const origin = isSnippet ? resolved : source;
+        if (declared || isSnippet) {
+            order.add(origin);
+            if (statement.specifiers.length === 0 && !sideEffects.has(origin)) {
+                sideEffects.set(origin, line);
+            }
+        }
+        for (const specifier of statement.specifiers) {
+            const local = specifier.local.name;
+            const imported = importedName(specifier);
+            track(local, describeImport(imported.imported, origin), declared || bare || isSnippet, line);
+            if (bare)
+                undeclared.set(local, source);
+            else if (declared || isSnippet) {
+                bindings.set(local, Object.assign({ source: origin, kind: declared ? 'package' : 'snippet', local }, imported));
+            }
+        }
+    }
+    return { bindings, undeclared, conflicts, sideEffects, order: [...order] };
+};
+export const collectConsts = (statements, options) => {
+    var _a;
+    const consts = new Map();
+    for (const [name, value] of Object.entries((_a = options.exportedConsts) !== null && _a !== void 0 ? _a : {})) {
+        if (IDENTIFIER_NAME.test(name))
+            consts.set(name, { expression: valueToExpression(value) });
+    }
+    const ignored = new Set();
+    for (const { statement } of statements) {
+        if (statement.type !== 'ExportNamedDeclaration')
+            continue;
+        const declaration = statement.declaration;
+        if ((declaration === null || declaration === void 0 ? void 0 : declaration.type) !== 'VariableDeclaration')
+            continue;
+        for (const declarator of declaration.declarations) {
+            if (declarator.id.type !== 'Identifier')
+                continue;
+            const converted = declaration.kind === 'const'
+                ? toStaticExpression(declarator.init, undefined, ignored)
+                : undefined;
+            consts.set(declarator.id.name, {
+                expression: (converted === null || converted === void 0 ? void 0 : converted.ok) ? converted.expression : undefined,
+            });
+        }
+    }
+    return consts;
+};
+export const bindingHead = (name) => name.includes(':') ? undefined : name.split('.')[0];
+export const referencesIn = (node, bindings) => {
+    const found = [];
+    walk(node, {
+        enter(estree, parent, key) {
+            var _a, _b;
+            if (estree.type === 'JSXIdentifier') {
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'JSXAttribute' ||
+                    ((parent === null || parent === void 0 ? void 0 : parent.type) === 'JSXMemberExpression' && key === 'property'))
+                    return;
+                if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'JSXNamespacedName')
+                    return;
+                if (bindings.has(estree.name))
+                    found.push({ name: estree.name, jsx: true, line: (_a = estree.loc) === null || _a === void 0 ? void 0 : _a.start.line });
+                return;
+            }
+            if (estree.type !== 'Identifier' || !bindings.has(estree.name))
+                return;
+            if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'MemberExpression' && key === 'property' && !parent.computed)
+                return;
+            if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'Property' && key === 'key' && !parent.computed)
+                return;
+            if ((parent === null || parent === void 0 ? void 0 : parent.type) === 'ImportSpecifier' ||
+                (parent === null || parent === void 0 ? void 0 : parent.type) === 'ImportDefaultSpecifier' ||
+                (parent === null || parent === void 0 ? void 0 : parent.type) === 'ImportNamespaceSpecifier') {
+                return;
+            }
+            found.push({ name: estree.name, jsx: false, line: (_b = estree.loc) === null || _b === void 0 ? void 0 : _b.start.line });
+        },
+    });
+    return found;
+};

package/dist/mdx/islands/island-module-builder.d.ts

@@ -0,0 +1,37 @@
+import type { JSXElement, JSXExpressionContainer, JSXFragment } from 'estree-jsx';
+import type { RootContent } from 'mdast';
+import { type Binding } from './island-bindings.js';
+import { type ConstEntry } from './static-expressions.js';
+import type { IslandError, IslandImport } from './types.js';
+type JsxNode = Extract<RootContent, {
+    type: 'mdxJsxFlowElement' | 'mdxJsxTextElement';
+}>;
+type JsxChild = JSXElement | JSXFragment | JSXExpressionContainer;
+export declare const MOVE_TO_SNIPPET = "Move this into a snippet.";
+export declare class IslandModuleBuilder {
+    private readonly rootName;
+    private readonly pagePath;
+    private readonly bindings;
+    private readonly undeclared;
+    private readonly consts;
+    private readonly sideEffects;
+    private readonly order;
+    readonly usedBindings: Map<string, Binding>;
+    readonly usedConsts: Set<string>;
+    readonly errors: IslandError[];
+    constructor(rootName: string, pagePath: string, bindings: Map<string, Binding>, undeclared: Map<string, string>, consts: Map<string, ConstEntry>, sideEffects: ReadonlyMap<string, unknown>, order: readonly string[]);
+    private url;
+    private fail;
+    private insideRoot;
+    element(node: JsxNode): JSXElement | JSXFragment | undefined;
+    private attribute;
+    private propFailure;
+    private intrinsic;
+    children(nodes: RootContent[]): JsxChild[];
+    private child;
+    private listItem;
+    private isRenderableText;
+    module(root: JSXElement | JSXFragment): string;
+    imports(): IslandImport[];
+}
+export {};