@cudoment/cudoc 0.1.0 → 0.2.0

package/README.md

@@ -1,58 +1,31 @@
 # @cudoment/cudoc
 
-Reuse document sections and tables from compiled MDX ASTs. Export a snapshot during compilation, load it on the server, select content by a stable anchor and render it with your site's components.
+Markdown document semantics, compilation, AST queries, cross-document embedding and dataset projection.
 
-```bash
-npm install @cudoment/cudoc
-```
-
-## Embedding
-
-Add the export plugin after the transforms whose results you want to store:
+ESM · Node.js 20+
 
-```js
-import exportAst from "@cudoment/cudoc/embed"
-
-const remarkPlugins = [
-  // Your remark transforms go here.
-  [exportAst, { sourceRoot: "docs", outDir: ".cudoc/ast" }],
-]
+```sh
+npm install @cudoment/cudoc
 ```
 
-Once the source document has compiled, read it in a server component or build script:
-
 ```js
-import { loadAst, sliceSectionByAnchorId } from "@cudoment/cudoc/embed"
-
-const document = loadAst("guide/limits", { outDir: ".cudoc/ast" })
-const section = sliceSectionByAnchorId(document, "rate-limits")
-if (!section) throw new Error("Missing section: rate-limits")
-// Render section.children with your site's components.
+import { compileDocument } from "@cudoment/cudoc/markdown"
+import { renderDocument } from "@cudoment/cudoc/render"
+
+const { tree } = compileDocument(
+  "## Setup (#setup)\n\n> [!NOTE] Requirements\n> Node.js 20+.",
+  { format: "md", syntax: {} },
+)
+const html = renderDocument(tree)
 ```
 
-The snapshot is the host's remark tree at the export plugin. Later host transforms and MDX component execution are outside it. Export and load validate the same AST contract and schema version. Section slices preserve referenced link, image and footnote definitions.
-
-Source compilation must finish before loading an embed. Keep compiler caches and exported ASTs together, and include the JSON files in deployments that read them at runtime. Queries do not execute MDX expressions; rendering and missing-reference policy belong to the consuming site.
-
-## Entry points
-
-| Import                                                                 | Runtime         | Purpose                                                 |
-| ---------------------------------------------------------------------- | --------------- | ------------------------------------------------------- |
-| `@cudoment/cudoc`                                                      | Browser or Node | AST contract, validation, traversal, syntax and queries |
-| `@cudoment/cudoc/query`                                                | Browser or Node | Sections, headings, text and table queries              |
-| `@cudoment/cudoc/ast`, `@cudoment/cudoc/syntax`, `@cudoment/cudoc/mdx` | Browser or Node | Focused common APIs                                     |
-| `@cudoment/cudoc/embed`                                                | Node            | AST export, loading and queries together                |
-| `@cudoment/cudoc/node/load-ast-file`                                   | Node            | Load a known JSON file without build-time path mapping  |
-| `@cudoment/cudoc/node/export-ast`, `@cudoment/cudoc/node/paths`        | Node            | Focused export and path APIs                            |
-
-All entries share one internal core. Internal source paths are not public exports and the core is not a separate npm package. Browser imports never depend on the Node entry points.
-
-For a server bundle that traces files, use `loadAstFile` from `@cudoment/cudoc/node/load-ast-file` with a concrete file path and configure your host's output file tracing.
-
-The optional `cudoc-remark`, `cudoc-docusaurus` and `cudoc-nextra` packages provide syntax transforms and host integration. Their publication is separate from this package.
-
-See the [embedding guide](https://github.com/cudoment/cudoc/blob/main/docs/embedding.md) and [project README](https://github.com/cudoment/cudoc#readme).
+The root and query APIs provide reusable AST operations. Import compilation from `/markdown`, rendering from `/render`, and collection from `/node/library`. Node entry points belong in build/server code. `/embed` handles individual AST snapshots; complete libraries and fenced embeds use the explicit `node/*` APIs. The core has no React runtime dependency.
 
-## License
+Choose `host`, `cudoc` or `both` independently for `headingAnchor`, `badge`, `tableCellList`, `callout` and `link`. The representative callout is `> [!NOTE] Title`. Authors do not register cudoc React components in the recommended setup. Syntax-only rendering needs no stored JSON; cross-document embedding requires document collection.
 
-[MIT](./LICENSE)
+- [Usage guide](https://github.com/cudoment/cudoc/tree/main/README.md#getting-started) · [한국어 가이드](https://github.com/cudoment/cudoc/tree/main/README.ko.md#시작하기)
+- [Markdown syntax](https://github.com/cudoment/cudoc/tree/main/docs/syntax.md)
+- [Embedding](https://github.com/cudoment/cudoc/tree/main/docs/embedding.md)
+- [Standalone HTML alongside a host](https://github.com/cudoment/cudoc/tree/main/docs/html.md#export-alongside-an-existing-site)
+- [API reference](https://github.com/cudoment/cudoc/tree/main/docs/api-reference/README.md)
+- [Runnable examples](https://github.com/cudoment/cudoc/tree/main/examples/README.md)

package/dist/dataset.d.ts

@@ -0,0 +1,10 @@
+import type { Root } from "mdast";
+export type ProjectionOptions = {
+    excludeNodeTypes?: string[];
+    excludeComponents?: string[];
+    stripProperties?: string[];
+};
+export declare const docsDatasetProjection: ProjectionOptions;
+/** Immutable recursive projection of already compiled ASTs, including nested nodes. */
+export declare function projectAst(tree: Root, options?: ProjectionOptions): Root;
+//# sourceMappingURL=dataset.d.ts.map

package/dist/dataset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.d.ts","sourceRoot":"","sources":["../src/dataset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAIjC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC5B,eAAe,CAAC,EAAE,MAAM,EAAE,CAAA;CAC3B,CAAA;AACD,eAAO,MAAM,qBAAqB,EAAE,iBAUnC,CAAA;AAED,uFAAuF;AACvF,wBAAgB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,iBAAsB,GAAG,IAAI,CAgC5E"}

package/dist/dataset.js

@@ -0,0 +1,44 @@
+import { validateAstContract } from "./internal/core/ast/validate.js";
+export const docsDatasetProjection = {
+    excludeComponents: [
+        "Table",
+        "TableHeader",
+        "TableBody",
+        "TableRow",
+        "TableHead",
+        "TableCell",
+        "DocDataEmbed",
+    ],
+};
+/** Immutable recursive projection of already compiled ASTs, including nested nodes. */
+export function projectAst(tree, options = {}) {
+    validateAstContract(tree);
+    const strip = new Set(options.stripProperties ?? []);
+    if (["type", "children"].some((key) => strip.has(key)))
+        throw new Error("cudoc: cannot strip structural AST properties");
+    const project = (value) => {
+        if (Array.isArray(value))
+            return value.flatMap((item) => {
+                const result = project(item);
+                return result === undefined ? [] : [result];
+            });
+        if (!value || typeof value !== "object")
+            return value;
+        const node = value;
+        if (options.excludeNodeTypes?.includes(node.type) ||
+            (node.type?.startsWith("mdxJsx") &&
+                node.name &&
+                options.excludeComponents?.includes(node.name)))
+            return undefined;
+        return Object.fromEntries(Object.entries(value)
+            .filter(([key]) => !strip.has(key))
+            .flatMap(([key, item]) => {
+            const result = project(item);
+            return result === undefined ? [] : [[key, result]];
+        }));
+    };
+    const result = project(tree);
+    validateAstContract(result);
+    return result;
+}
+//# sourceMappingURL=dataset.js.map

package/dist/dataset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.js","sourceRoot":"","sources":["../src/dataset.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAA;AAOrE,MAAM,CAAC,MAAM,qBAAqB,GAAsB;IACtD,iBAAiB,EAAE;QACjB,OAAO;QACP,aAAa;QACb,WAAW;QACX,UAAU;QACV,WAAW;QACX,WAAW;QACX,cAAc;KACf;CACF,CAAA;AAED,uFAAuF;AACvF,MAAM,UAAU,UAAU,CAAC,IAAU,EAAE,UAA6B,EAAE;IACpE,mBAAmB,CAAC,IAAI,CAAC,CAAA;IACzB,MAAM,KAAK,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,eAAe,IAAI,EAAE,CAAC,CAAA;IACpD,IAAI,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpD,MAAM,IAAI,KAAK,CAAC,+CAA+C,CAAC,CAAA;IAClE,MAAM,OAAO,GAAG,CAAC,KAAc,EAAW,EAAE;QAC1C,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC;YACtB,OAAO,KAAK,CAAC,OAAO,CAAC,CAAC,IAAI,EAAE,EAAE;gBAC5B,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;gBAC5B,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA;YAC7C,CAAC,CAAC,CAAA;QACJ,IAAI,CAAC,KAAK,IAAI,OAAO,KAAK,KAAK,QAAQ;YAAE,OAAO,KAAK,CAAA;QACrD,MAAM,IAAI,GAAG,KAAqB,CAAA;QAClC,IACE,OAAO,CAAC,gBAAgB,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;YAC7C,CAAC,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,QAAQ,CAAC;gBAC9B,IAAI,CAAC,IAAI;gBACT,OAAO,CAAC,iBAAiB,EAAE,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEjD,OAAO,SAAS,CAAA;QAClB,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,KAAK,CAAC;aAClB,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;aAClC,OAAO,CAAC,CAAC,CAAC,GAAG,EAAE,IAAI,CAAC,EAAE,EAAE;YACvB,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;YAC5B,OAAO,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,CAAA;QACpD,CAAC,CAAC,CACL,CAAA;IACH,CAAC,CAAA;IACD,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAS,CAAA;IACpC,mBAAmB,CAAC,MAAM,CAAC,CAAA;IAC3B,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/document.d.ts

@@ -0,0 +1,74 @@
+/** Portable document semantics. Parser and rendering adapters share this model. */
+import type { Root, PhrasingContent } from "mdast";
+import type { Position } from "unist";
+import { type TableColumnLayoutOptions } from "./internal/transforms/table-column-layout/index.js";
+declare module "mdast" {
+    interface RootData {
+        cudocEmbedPrefix?: string;
+    }
+}
+export type SyntaxMode = "host" | "cudoc" | "both";
+export type SyntaxOptions = Partial<Record<"headingAnchor" | "badge" | "tableCellList" | "callout" | "link", SyntaxMode>>;
+export type Host = "markdown" | "next" | "docusaurus" | "nextra" | "vitepress" | "html" | "docs";
+export type DocumentDiagnostic = {
+    code: string;
+    message: string;
+    position?: Position;
+};
+export type DocumentOptions = {
+    syntax?: SyntaxOptions;
+    host?: Host;
+    format?: "md" | "mdx";
+    calloutTypes?: string[];
+    components?: Record<string, {
+        kind: "callout" | "link" | "badge";
+        typeAttribute?: string;
+        titleAttribute?: string;
+        urlAttribute?: string;
+    }>;
+    tableColumnLayout?: TableColumnLayoutOptions[];
+    /** Hosts use their native slugger later. Standalone compilers assign IDs here. */
+    headingIds?: "host" | "generate";
+};
+export type DocumentData = {
+    hName?: string;
+    hProperties?: Record<string, unknown>;
+    cudoc?: {
+        kind: string;
+        type?: string;
+        title?: string;
+        badge?: string;
+        explicitId?: boolean;
+    };
+    [key: string]: unknown;
+};
+export type DocumentNode = {
+    type: string;
+    value?: string;
+    name?: string | null;
+    depth?: number;
+    url?: string;
+    identifier?: string;
+    label?: string;
+    attributes?: unknown;
+    children?: DocumentNode[];
+    position?: Position;
+    data?: DocumentData;
+    [key: string]: unknown;
+};
+export declare const DEFAULT_SYNTAX: Required<SyntaxOptions>;
+export declare function resolveSyntax(syntax?: SyntaxOptions): Required<SyntaxOptions>;
+export declare const visibleHeadingText: (node: DocumentNode) => string;
+export declare const nodeText: (node: DocumentNode) => string;
+export declare const isCudoc: (mode: SyntaxMode) => mode is "cudoc" | "both";
+export declare const isHost: (mode: SyntaxMode) => mode is "host" | "both";
+/** Read static JSX/directive attributes without evaluating expressions. */
+export declare function staticAttributes(node: DocumentNode): Record<string, unknown>;
+export declare function hasDynamicAttributes(node: DocumentNode): boolean;
+export declare const canonicalCalloutType: (type: string) => string;
+export declare function makeCallout(type: string, title: DocumentNode[], children: DocumentNode[], position?: Position): DocumentNode;
+/** Convert generated/static native JSX to mdast data understood by mdast-to-hast. */
+export declare function lowerNativeElements(tree: Root): void;
+/** Mutates the compiler's actual tree. It never reparses the source document. */
+export declare function normalizeDocument(tree: Root, source: string, options?: DocumentOptions, inlineParser?: (source: string) => PhrasingContent[]): DocumentDiagnostic[];
+//# sourceMappingURL=document.d.ts.map

package/dist/document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["../src/document.ts"],"names":[],"mappings":"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"}

package/dist/document.js

@@ -0,0 +1,435 @@
+import GithubSlugger from "github-slugger";
+import { walk } from "./internal/core/walk.js";
+import { parseTableCellList, buildTableCellChildren, hasTableCellListPattern, } from "./internal/transforms/table-cell-list/index.js";
+import { createTableColumnLayoutTransform, resolveTableColumnLayoutOptions, } from "./internal/transforms/table-column-layout/index.js";
+export const DEFAULT_SYNTAX = {
+    headingAnchor: "cudoc",
+    badge: "cudoc",
+    tableCellList: "cudoc",
+    callout: "cudoc",
+    link: "host",
+};
+export function resolveSyntax(syntax = {}) {
+    if (!syntax || typeof syntax !== "object" || Array.isArray(syntax))
+        throw new TypeError("cudoc: syntax must be an object");
+    for (const [key, value] of Object.entries(syntax)) {
+        if (!Object.hasOwn(DEFAULT_SYNTAX, key) ||
+            !["host", "cudoc", "both"].includes(value))
+            throw new TypeError(`cudoc: invalid syntax.${key}: ${value}`);
+    }
+    return { ...DEFAULT_SYNTAX, ...syntax };
+}
+export const visibleHeadingText = (node) => (node.children
+    ?.filter((n) => !["badge", "permalink"].includes(n.data?.cudoc?.kind ?? ""))
+    .map(nodeText)
+    .join("") ?? "").trim();
+export const nodeText = (node) => node.value ?? node.children?.map(nodeText).join("") ?? "";
+export const isCudoc = (mode) => mode !== "host";
+export const isHost = (mode) => mode !== "cudoc";
+/** Read static JSX/directive attributes without evaluating expressions. */
+export function staticAttributes(node) {
+    if (!Array.isArray(node.attributes))
+        return { ...(node.attributes ?? {}) };
+    const result = {};
+    for (const attr of node.attributes) {
+        if (attr.type !== "mdxJsxAttribute" || !attr.name)
+            continue;
+        if (attr.value === null)
+            result[attr.name] = true;
+        else if (typeof attr.value === "string")
+            result[attr.name] = attr.value;
+        else if (attr.value &&
+            typeof attr.value === "object" &&
+            "value" in attr.value) {
+            try {
+                result[attr.name] = JSON.parse(String(attr.value.value));
+            }
+            catch {
+                /* Dynamic values stay opaque. */
+            }
+        }
+    }
+    return result;
+}
+export function hasDynamicAttributes(node) {
+    if (!Array.isArray(node.attributes))
+        return false;
+    const attrs = staticAttributes(node);
+    return node.attributes.some((attr) => attr.type !== "mdxJsxAttribute" ||
+        !attr.name ||
+        !Object.hasOwn(attrs, attr.name));
+}
+export const canonicalCalloutType = (type) => ({
+    info: "note",
+    default: "note",
+    error: "caution",
+    danger: "caution",
+    warn: "warning",
+})[type.toLowerCase()] ?? type.toLowerCase();
+const text = (value) => ({ type: "text", value });
+const badgeNode = (value) => ({
+    type: "strong",
+    children: [text(value)],
+    data: {
+        hName: "span",
+        hProperties: { className: ["cudoc-badge"] },
+        cudoc: { kind: "badge" },
+    },
+});
+export function makeCallout(type, title, children, position) {
+    type = canonicalCalloutType(type);
+    return {
+        type: "blockquote",
+        position,
+        data: {
+            hName: "aside",
+            hProperties: {
+                className: ["cudoc-callout", `cudoc-callout-${type}`],
+                "data-callout": type,
+            },
+            cudoc: { kind: "callout", type, title: title.map(nodeText).join("") },
+        },
+        children: [
+            {
+                type: "paragraph",
+                data: {
+                    hProperties: { className: ["cudoc-callout-title"] },
+                    cudoc: { kind: "calloutTitle" },
+                },
+                children: title.length ? title : [text(type.toUpperCase())],
+            },
+            ...children,
+        ],
+    };
+}
+/** Split a paragraph at its first physical line break without flattening emphasis. */
+function splitLine(nodes) {
+    const before = [];
+    for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        const offset = node.type === "text" ? node.value.indexOf("\n") : -1;
+        if (offset >= 0 || node.type === "break") {
+            if (offset > 0)
+                before.push({ ...node, value: node.value.slice(0, offset) });
+            const after = offset >= 0 && node.value.slice(offset + 1)
+                ? [{ ...node, value: node.value.slice(offset + 1) }]
+                : [];
+            return [before, [...after, ...nodes.slice(i + 1)]];
+        }
+        before.push(node);
+    }
+    return [before, []];
+}
+const nativeTags = new Set("a abbr b blockquote br header footer nav caption code dd del details div dl dt em figcaption figure hr i img kbd li ol p pre s section small span strong sub summary sup table tbody td th thead tr u ul aside".split(" "));
+const tableTags = {
+    Table: "table",
+    TableHeader: "thead",
+    TableBody: "tbody",
+    TableRow: "tr",
+    TableHead: "th",
+    TableCell: "td",
+};
+/** Convert generated/static native JSX to mdast data understood by mdast-to-hast. */
+export function lowerNativeElements(tree) {
+    const lower = (node) => {
+        if (node.children)
+            node.children = node.children.map(lower);
+        if (!node.type.startsWith("mdxJsx") ||
+            !node.name ||
+            !nativeTags.has(node.name) ||
+            hasDynamicAttributes(node))
+            return node;
+        const attrs = staticAttributes(node);
+        if (node.name === "br")
+            return { type: "break", position: node.position };
+        if (node.name === "a" && typeof attrs.href === "string")
+            return {
+                type: "link",
+                url: attrs.href,
+                children: node.children ?? [],
+                data: { hProperties: attrs },
+                position: node.position,
+            };
+        if (node.name === "img" && typeof attrs.src === "string")
+            return {
+                type: "image",
+                url: attrs.src,
+                alt: attrs.alt ?? "",
+                data: { hProperties: attrs },
+                position: node.position,
+            };
+        if (attrs.style && typeof attrs.style === "object")
+            attrs.style = Object.entries(attrs.style)
+                .map(([key, value]) => `${key.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`)}:${value}`)
+                .join(";");
+        return {
+            type: node.type === "mdxJsxTextElement" ? "strong" : "blockquote",
+            children: node.children ?? [],
+            position: node.position,
+            data: {
+                hName: node.name,
+                hProperties: attrs,
+                cudoc: { kind: "element" },
+                ...(node.data?._mdxExplicitJsx ? { _mdxExplicitJsx: true } : {}),
+            },
+        };
+    };
+    tree.children = tree.children.map((n) => lower(n));
+}
+/** Mutates the compiler's actual tree. It never reparses the source document. */
+export function normalizeDocument(tree, source, options = {}, inlineParser) {
+    const syntax = resolveSyntax(options.syntax);
+    const host = options.host ?? "markdown";
+    if (![
+        "markdown",
+        "next",
+        "docusaurus",
+        "nextra",
+        "vitepress",
+        "html",
+        "docs",
+    ].includes(host))
+        throw new TypeError(`cudoc: unknown host ${host}`);
+    if (options.calloutTypes !== undefined &&
+        (!Array.isArray(options.calloutTypes) ||
+            options.calloutTypes.some((type) => typeof type !== "string" || !/^[a-z][\w-]*$/i.test(type))))
+        throw new TypeError("cudoc: calloutTypes must contain type names");
+    const diagnostics = [];
+    const types = new Set([
+        "note",
+        "tip",
+        "important",
+        "warning",
+        "caution",
+        ...(options.calloutTypes ?? []).map((t) => t.toLowerCase()),
+    ]);
+    const mappings = {
+        ...(host === "docs"
+            ? {
+                Infobox: { kind: "callout" },
+                Link: { kind: "link" },
+                IconLink: { kind: "link" },
+            }
+            : {}),
+        ...(host === "nextra" ? { Callout: { kind: "callout" } } : {}),
+        ...(host === "docusaurus"
+            ? { Admonition: { kind: "callout" } }
+            : {}),
+        ...options.components,
+    };
+    const warn = (node, code, message) => diagnostics.push({ code, message, position: node.position });
+    const fail = (node, message) => {
+        throw new Error(`cudoc: ${message} at ${node.position?.start.line ?? "?"}:${node.position?.start.column ?? "?"}`);
+    };
+    const normalize = (node, ancestors) => {
+        if (node.data?.cudoc?.kind === "badge")
+            return node;
+        if (node.type === "heading") {
+            const ids = [];
+            const existing = node.data?.hProperties?.id;
+            if (typeof existing === "string" &&
+                node.data?.cudoc?.explicitId !== false)
+                ids.push(existing);
+            const clean = (child) => {
+                if (child.type === "text") {
+                    let value = child.value;
+                    if (isCudoc(syntax.headingAnchor))
+                        value = value.replace(/\(#([^\s)]+)\)/g, (_, id) => {
+                            ids.push(id);
+                            return "";
+                        });
+                    if (isHost(syntax.headingAnchor) &&
+                        ["docusaurus", "vitepress"].includes(host))
+                        value = value.replace(/\{#([^\s}]+)\}/g, (_, id) => {
+                            ids.push(id);
+                            return "";
+                        });
+                    if (isHost(syntax.headingAnchor) && host === "nextra")
+                        value = value.replace(/\[#([^\s\]]+)\]/g, (_, id) => {
+                            ids.push(id);
+                            return "";
+                        });
+                    return [{ ...child, value }];
+                }
+                if (isHost(syntax.headingAnchor) &&
+                    host === "docusaurus" &&
+                    child.type.includes("Expression")) {
+                    const match = child.value?.match(/^\s*\/\*\s*#([^\s*]+)\s*\*\/\s*$/);
+                    if (match) {
+                        ids.push(match[1]);
+                        return [];
+                    }
+                }
+                if (child.name === "Anchor" &&
+                    isHost(syntax.headingAnchor) &&
+                    !hasDynamicAttributes(child)) {
+                    const attrs = staticAttributes(child);
+                    if (typeof attrs.id === "string")
+                        ids.push(attrs.id);
+                    if (typeof attrs.badge === "string")
+                        return [badgeNode(attrs.badge)];
+                    return [];
+                }
+                if (child.children &&
+                    ["strong", "emphasis", "delete"].includes(child.type))
+                    child.children = child.children.flatMap(clean);
+                return [child];
+            };
+            node.children = node.children?.flatMap(clean);
+            const last = node.children?.at(-1);
+            if (last?.type === "text")
+                last.value = last.value.trimEnd();
+            if (new Set(ids).size > 1)
+                fail(node, `conflicting heading IDs: ${ids.join(", ")}`);
+            if (ids.length)
+                node.data = {
+                    ...node.data,
+                    hProperties: { ...node.data?.hProperties, id: ids[0] },
+                    cudoc: { kind: "heading", explicitId: true },
+                };
+        }
+        if (node.type === "blockquote" && node.data?.cudoc?.kind !== "callout") {
+            const paragraph = node.children?.[0];
+            const first = paragraph?.type === "paragraph" ? paragraph.children?.[0] : undefined;
+            const match = first?.type === "text"
+                ? first.value?.match(/^\[!([\w-]+)\](?:[ \t]+|(?=\r?\n|$))/)
+                : undefined;
+            if (match &&
+                (isCudoc(syntax.callout) ||
+                    (isHost(syntax.callout) && host === "vitepress"))) {
+                const type = match[1].toLowerCase();
+                if (!types.has(type))
+                    warn(node, "UNKNOWN_CALLOUT_TYPE", `Unregistered callout type: ${match[1]}`);
+                else {
+                    const parts = [
+                        { ...first, value: first.value.slice(match[0].length) },
+                        ...paragraph.children.slice(1),
+                    ];
+                    const [title, remainder] = splitLine(parts);
+                    node = makeCallout(type, title.filter((n) => n.type !== "text" || n.value), [
+                        ...(remainder.length
+                            ? [{ type: "paragraph", children: remainder }]
+                            : []),
+                        ...node.children.slice(1),
+                    ], node.position);
+                }
+            }
+        }
+        if (node.type === "containerDirective" &&
+            isHost(syntax.callout) &&
+            host === "docusaurus" &&
+            node.name &&
+            ["note", "tip", "info", "warning", "danger", ...types].includes(node.name)) {
+            const label = node.children?.[0]?.data?.directiveLabel
+                ? node.children[0]
+                : undefined;
+            const attrs = staticAttributes(node);
+            node = makeCallout(node.name, label?.children ?? [], node.children?.slice(label ? 1 : 0) ?? [], node.position);
+            if (typeof attrs.id === "string")
+                node.data.hProperties.id = attrs.id;
+            if (typeof attrs.class === "string")
+                node.data.hProperties.className.push(...attrs.class.split(/\s+/));
+        }
+        if (node.name && node.type.startsWith("mdxJsx")) {
+            const map = mappings[node.name];
+            const attrs = staticAttributes(node);
+            if (hasDynamicAttributes(node)) {
+                if (map || nativeTags.has(node.name))
+                    warn(node, "DYNAMIC_COMPONENT", `Preserved dynamic attributes on ${node.name}; portable rendering requires an explicit renderer`);
+            }
+            else if (map?.kind === "callout" && isHost(syntax.callout))
+                node = makeCallout(String(attrs[map.typeAttribute ?? "type"] ?? "note"), attrs[map.titleAttribute ?? "title"]
+                    ? [text(String(attrs[map.titleAttribute ?? "title"]))]
+                    : [], node.children ?? [], node.position);
+            else if (map?.kind === "link" &&
+                isHost(syntax.link) &&
+                typeof attrs[map.urlAttribute ?? "href"] === "string")
+                node = {
+                    type: "link",
+                    url: String(attrs[map.urlAttribute ?? "href"]),
+                    children: node.children ?? [],
+                    position: node.position,
+                };
+            else if ((map?.kind === "badge" || node.name === "Badge") &&
+                isHost(syntax.badge))
+                node = badgeNode(nodeText(node));
+            else if (host === "docs" && tableTags[node.name])
+                node.name = tableTags[node.name];
+        }
+        if (node.type === "tableCell" &&
+            isCudoc(syntax.tableCellList) &&
+            node.position) {
+            const raw = source
+                .slice(node.position.start.offset, node.position.end.offset)
+                .replace(/^\s*\|\s*/, "")
+                .replace(/\s*\|\s*$/, "");
+            if (hasTableCellListPattern(raw) && raw.trim() !== "-")
+                node.children = buildTableCellChildren(parseTableCellList(raw, options.format ?? "md", inlineParser));
+        }
+        if (node.children)
+            node.children = node.children.flatMap((child) => {
+                if (child.type === "text" &&
+                    isCudoc(syntax.badge) &&
+                    ![...ancestors, node].some((p) => ["link", "linkReference", "code", "inlineCode"].includes(p.type))) {
+                    const parts = child.value.split(/\(@([^)]*)\)/g);
+                    if (parts.length > 1) {
+                        if (node.type === "heading")
+                            node.data = {
+                                ...node.data,
+                                cudoc: {
+                                    ...node.data?.cudoc,
+                                    kind: "heading",
+                                    badge: parts.filter((_, i) => i % 2).at(-1),
+                                },
+                            };
+                        return parts.map((value, i) => i % 2 ? badgeNode(value) : text(value));
+                    }
+                }
+                return [normalize(child, [...ancestors, node])];
+            });
+        return node;
+    };
+    tree.children = tree.children.map((n) => normalize(n, []));
+    for (const rule of options.tableColumnLayout ?? [])
+        walk({
+            tree,
+            state: { source },
+            preTransforms: [],
+            postTransforms: [
+                createTableColumnLayoutTransform(resolveTableColumnLayoutOptions(rule)),
+            ],
+        });
+    lowerNativeElements(tree);
+    const slugger = new GithubSlugger();
+    const ids = new Set();
+    const headings = [];
+    const collect = (node) => {
+        if (node.type === "heading")
+            headings.push(node);
+        node.children?.forEach(collect);
+    };
+    collect(tree);
+    for (const node of headings) {
+        const id = node.data?.hProperties?.id;
+        if (typeof id === "string") {
+            if (ids.has(id))
+                fail(node, `duplicate heading ID: ${id}`);
+            ids.add(id);
+        }
+    }
+    if (options.headingIds !== "host")
+        for (const node of headings)
+            if (!node.data?.hProperties?.id) {
+                const title = visibleHeadingText(node);
+                let id = slugger.slug(title);
+                while (ids.has(id))
+                    id = slugger.slug(title);
+                ids.add(id);
+                node.data = {
+                    ...node.data,
+                    hProperties: { ...node.data?.hProperties, id },
+                };
+            }
+    return diagnostics;
+}
+//# sourceMappingURL=document.js.map