@publish.os/nextjs 0.0.1-alpha.90 → 0.0.1-alpha.91

package/dist/components/blocks/agent-actions.js

@@ -0,0 +1,594 @@
+"use client";
+
+// src/modules/agent-actions/agent-actions.tsx
+import { AnimatedIconSwap } from "@components/blocks/animated-icon-swap";
+import {
+  Button,
+  buttonVariants
+} from "@components/ui/button";
+import { ButtonGroup, ButtonGroupSeparator } from "@components/ui/button-group";
+import {
+  Menu,
+  MenuGroup,
+  MenuGroupLabel,
+  MenuItem,
+  MenuLinkItem,
+  MenuPopup,
+  MenuPortal,
+  MenuPositioner,
+  MenuSeparator,
+  MenuTrigger
+} from "@components/ui/menu";
+import {
+  CaretDownIcon,
+  CheckIcon,
+  CopyIcon,
+  MarkdownLogoIcon
+} from "@phosphor-icons/react/ssr";
+import { cn } from "@publish.os/nextjs/utils/cn";
+import {
+  createContext,
+  Fragment,
+  use,
+  useCallback,
+  useEffect,
+  useRef,
+  useState
+} from "react";
+import { flushSync } from "react-dom";
+import { jsx, jsxs } from "@publish.os/nextjs/jsx-runtime";
+var DEFAULT_PROMPT_SUFFIX = "I want to ask questions about it.", COPY_FEEDBACK_MS = 1600;
+function normalizePath(path) {
+  let [pathname = "/"] = path.split(/[?#]/), prefixed = pathname.startsWith("/") ? pathname : `/${pathname}`;
+  return prefixed === "/" ? prefixed : prefixed.replace(/\/+$/, "");
+}
+function markdownPathForPagePath(path) {
+  let normalized = normalizePath(path);
+  return normalized === "/" ? "/index.md" : normalized.endsWith(".md") ? normalized : `${normalized}.md`;
+}
+function isAbsoluteUrl(url) {
+  return /^[a-z][a-z\d+\-.]*:/i.test(url);
+}
+function absoluteUrl(url, siteUrl) {
+  if (isAbsoluteUrl(url) || !siteUrl) return url;
+  try {
+    return new URL(url, siteUrl).toString();
+  } catch {
+    return url;
+  }
+}
+function mergeRel(rel) {
+  let values = new Set((rel ?? "").split(/\s+/).filter(Boolean));
+  return values.add("noreferrer"), Array.from(values).join(" ");
+}
+function createPrompt(markdownUrl) {
+  return `Read ${markdownUrl}, ${DEFAULT_PROMPT_SUFFIX}`;
+}
+function providerPromptUrl(baseUrl, prompt, param = "q") {
+  let url = new URL(baseUrl);
+  return url.searchParams.set(param, prompt), url.toString();
+}
+var DEFAULT_PRIMARY_ACTION = {
+  id: "copy-page-markdown-primary",
+  title: "Copy Markdown",
+  copy: "page-markdown"
+}, DEFAULT_ACTION_GROUPS = [
+  {
+    id: "open-in-ai",
+    title: "Open in",
+    actions: [
+      {
+        id: "open-claude",
+        title: "Claude",
+        href: ({ prompt }) => providerPromptUrl("https://claude.ai/new", prompt),
+        openInNew: !0
+      },
+      {
+        id: "open-chatgpt",
+        title: "ChatGPT",
+        href: ({ prompt }) => providerPromptUrl("https://chatgpt.com/?hints=search", prompt),
+        openInNew: !0
+      },
+      {
+        id: "open-cursor",
+        title: "Cursor",
+        href: ({ prompt }) => providerPromptUrl("https://cursor.com/link/prompt", prompt, "text"),
+        openInNew: !0
+      },
+      {
+        id: "open-copilot",
+        title: "Copilot",
+        href: ({ prompt }) => providerPromptUrl("https://copilot.microsoft.com/", prompt),
+        openInNew: !0
+      },
+      {
+        id: "open-t3-chat",
+        title: "T3 Chat",
+        href: ({ prompt }) => providerPromptUrl("https://t3.chat/new", prompt),
+        openInNew: !0
+      },
+      {
+        id: "open-github",
+        title: "GitHub source",
+        href: ({ sourceUrl }) => sourceUrl,
+        openInNew: !0,
+        disabled: ({ sourceUrl }) => !sourceUrl
+      }
+    ]
+  },
+  {
+    id: "page-actions",
+    title: "Page",
+    actions: [
+      {
+        id: "copy-page-markdown",
+        title: "Copy markdown",
+        copy: "page-markdown"
+      },
+      {
+        id: "view-page-markdown",
+        title: "View as Markdown",
+        href: ({ markdownPath }) => markdownPath
+      },
+      {
+        id: "copy-page-link",
+        title: "Copy link",
+        copy: "page-link"
+      }
+    ]
+  }
+];
+function resolveValue(value, context) {
+  return typeof value == "function" ? value(context) : value;
+}
+async function copyText(text) {
+  if (!navigator.clipboard?.writeText)
+    throw new Error("Clipboard access is not available in this browser.");
+  await navigator.clipboard.writeText(text);
+}
+function revisionRequestPath(path, revision) {
+  if (!revision) return path;
+  let separator = path.includes("?") ? "&" : "?";
+  return `${path}${separator}publishos_revision=${encodeURIComponent(revision)}`;
+}
+async function markdownHash(text) {
+  if (!globalThis.crypto?.subtle)
+    throw new Error("This browser cannot verify the current Markdown version.");
+  let digest = await globalThis.crypto.subtle.digest(
+    "SHA-256",
+    new TextEncoder().encode(text)
+  );
+  return `sha256-${Array.from(
+    new Uint8Array(digest),
+    (byte) => byte.toString(16).padStart(2, "0")
+  ).join("").slice(0, 32)}`;
+}
+var AgentActionsContext = createContext(
+  null
+);
+function useAgentActions() {
+  let context = use(AgentActionsContext);
+  if (!context)
+    throw new Error("AgentActions parts must be inside AgentActions.Root.");
+  return context;
+}
+function AgentActionsProvider({
+  actionGroups,
+  buttonSize = "xs",
+  buttonVariant = "outline",
+  className,
+  markdown,
+  markdownPath,
+  markdownRevision,
+  markdownUrl,
+  menuLabel = "More agent actions",
+  markdownLinkLabel = "View as Markdown",
+  pagePath,
+  pageUrl,
+  primaryAction,
+  prompt,
+  siteUrl,
+  sourceUrl,
+  showMarkdownLink = !0,
+  children,
+  ...props
+}) {
+  let [copiedActionId, setCopiedActionId] = useState(), [copyFeedback, setCopyFeedback] = useState(), [menuOpen, setMenuOpen] = useState(!1), menuTriggerRef = useRef(null), menuActionsRef = useRef(null), menuOpenRef = useRef(!1), markdownPreparationRef = useRef(null), currentMarkdownKeyRef = useRef(""), resetTimerRef = useRef(
+    void 0
+  ), closeMenu = useCallback(() => {
+    flushSync(() => {
+      menuOpenRef.current = !1, setMenuOpen(!1), menuActionsRef.current?.close(), menuActionsRef.current?.unmount();
+    });
+  }, []);
+  useEffect(() => () => {
+    resetTimerRef.current && clearTimeout(resetTimerRef.current);
+  }, []);
+  let resolvedPagePath = pagePath ?? "/", resolvedMarkdownPath = markdownPath ?? markdownPathForPagePath(resolvedPagePath), resolvedMarkdownUrl = absoluteUrl(
+    markdownUrl ?? resolvedMarkdownPath,
+    siteUrl
+  ), context = {
+    markdown,
+    markdownPath: resolvedMarkdownPath,
+    markdownUrl: resolvedMarkdownUrl,
+    pagePath: resolvedPagePath,
+    pageUrl: absoluteUrl(pageUrl ?? resolvedPagePath, siteUrl),
+    prompt: prompt ?? createPrompt(resolvedMarkdownUrl),
+    sourceUrl
+  }, markdownKey = `${context.markdownUrl}\0${markdownRevision ?? "unversioned"}`;
+  currentMarkdownKeyRef.current = markdownKey, useEffect(
+    () => () => {
+      markdownPreparationRef.current?.controller?.abort(), markdownPreparationRef.current = null;
+    },
+    []
+  ), useEffect(() => {
+    let preparation = markdownPreparationRef.current;
+    preparation && preparation.key !== markdownKey && (preparation.controller?.abort(), markdownPreparationRef.current = null, setCopyFeedback(void 0), setCopiedActionId(void 0));
+  }, [markdownKey]);
+  let resolvedPrimaryAction = primaryAction ?? DEFAULT_PRIMARY_ACTION, resolvedActionGroups = actionGroups ?? DEFAULT_ACTION_GROUPS, markCopied = (actionId) => {
+    resetTimerRef.current && clearTimeout(resetTimerRef.current), setCopiedActionId(actionId), resetTimerRef.current = setTimeout(() => {
+      setCopiedActionId(void 0);
+    }, COPY_FEEDBACK_MS);
+  }, markdownPreparation = () => {
+    let current = markdownPreparationRef.current;
+    if (current?.key === markdownKey) return current;
+    current?.controller?.abort();
+    let next = { key: markdownKey };
+    return markdownPreparationRef.current = next, next;
+  }, prepareMarkdown = () => {
+    if (context.markdown !== void 0 || !context.markdownUrl) return;
+    let record = markdownPreparation();
+    if (record.text !== void 0 || record.pending) return;
+    let controller = new AbortController();
+    record.controller = controller;
+    let requestPath = revisionRequestPath(
+      context.markdownPath,
+      markdownRevision
+    ), localPreview = process.env.NODE_ENV !== "production", request = async (cache) => {
+      let response;
+      try {
+        response = await fetch(requestPath, {
+          cache,
+          signal: controller.signal
+        });
+      } catch {
+        throw new Error("The Markdown page could not be loaded.");
+      }
+      if (!response.ok)
+        throw new Error(
+          `The Markdown page could not be loaded (${response.status}).`
+        );
+      return response.text();
+    }, pending = (async () => {
+      let firstBody = await request(localPreview ? "no-store" : "default");
+      if (!markdownRevision || await markdownHash(firstBody) === markdownRevision)
+        return firstBody;
+      let refreshedBody = await request(localPreview ? "no-store" : "reload");
+      if (await markdownHash(refreshedBody) !== markdownRevision)
+        throw new Error(
+          "The Markdown page changed while loading. Refresh the page and try again."
+        );
+      return refreshedBody;
+    })().then((text) => (markdownPreparationRef.current === record && currentMarkdownKeyRef.current === record.key && (record.text = text), text)).catch((error) => {
+      throw markdownPreparationRef.current === record && (markdownPreparationRef.current = null), error;
+    }).finally(() => {
+      record.pending = void 0, record.controller = void 0;
+    });
+    record.pending = pending, pending.catch(() => {
+    });
+  }, setMenuOpenState = (open) => {
+    menuOpenRef.current = open, setMenuOpen(open), open && resolvedActionGroups.some(
+      (group) => group.actions.some(
+        (action) => action.copy === "page-markdown" && !resolveValue(action.disabled, context)
+      )
+    ) && prepareMarkdown();
+  }, prepareAction = (action) => {
+    action.copy === "page-markdown" && !resolveValue(action.disabled, context) && prepareMarkdown();
+  }, finishAction = async (action, clipboardWrite, actionMarkdownKey) => {
+    try {
+      if (await clipboardWrite, actionMarkdownKey && currentMarkdownKeyRef.current !== actionMarkdownKey)
+        return;
+      markCopied(action.id), setCopyFeedback("Copied to clipboard."), await action.onSelect?.(context);
+    } catch (error) {
+      if (actionMarkdownKey && currentMarkdownKeyRef.current !== actionMarkdownKey)
+        return;
+      setCopyFeedback(
+        error instanceof Error ? `${error.message} Try again.` : "The action failed. Try again."
+      );
+    }
+  }, handleAction = (action) => {
+    if (resolveValue(action.disabled, context)) return;
+    if (setCopyFeedback(void 0), setCopiedActionId(void 0), !action.copy) {
+      Promise.resolve(action.onSelect?.(context)).catch(
+        (error) => {
+          setCopyFeedback(
+            error instanceof Error ? `${error.message} Try again.` : "The action failed. Try again."
+          );
+        }
+      );
+      return;
+    }
+    if (action.copy === "page-markdown" && context.markdown === void 0) {
+      if (!context.markdownUrl) {
+        setCopyFeedback("The Markdown page URL is not available. Try again.");
+        return;
+      }
+      let record = markdownPreparation();
+      if (record.text !== void 0) {
+        if (!record.text) {
+          setCopyFeedback("There is no Markdown content to copy. Try again.");
+          return;
+        }
+        finishAction(action, copyText(record.text), record.key);
+        return;
+      }
+      setCopyFeedback("Preparing Markdown\u2026"), prepareMarkdown();
+      let pending = markdownPreparationRef.current?.pending;
+      if (!pending) return;
+      pending.then(
+        (text) => {
+          if (currentMarkdownKeyRef.current === record.key) {
+            if (!text) {
+              setCopyFeedback("There is no Markdown content to copy. Try again.");
+              return;
+            }
+            finishAction(action, copyText(text), record.key);
+          }
+        },
+        (error) => {
+          currentMarkdownKeyRef.current === record.key && setCopyFeedback(
+            error instanceof Error ? `${error.message} Try again.` : "The action failed. Try again."
+          );
+        }
+      );
+      return;
+    }
+    let value = action.copy === "page-markdown" ? context.markdown : action.copy === "page-link" ? context.pageUrl : action.copy === "markdown-link" ? context.markdownUrl : action.copy;
+    if (!value) {
+      setCopyFeedback("There is no Markdown content to copy. Try again.");
+      return;
+    }
+    finishAction(action, copyText(value));
+  }, iconForAction = (action) => {
+    let copied = copiedActionId === action.id;
+    return action.copy === "page-markdown" ? /* @__PURE__ */ jsx(
+      AnimatedIconSwap,
+      {
+        active: copied,
+        activeIcon: /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": "true", className: "size-4" }),
+        defaultIcon: action.icon ?? /* @__PURE__ */ jsx(CopyIcon, { "aria-hidden": "true", className: "size-4" }),
+        size: 16
+      }
+    ) : copied ? /* @__PURE__ */ jsx(CheckIcon, { "aria-hidden": "true", className: "size-4" }) : action.icon;
+  }, contextValue = {
+    buttonSize,
+    buttonVariant,
+    closeMenu,
+    copyFeedback,
+    menuActionsRef,
+    menuLabel,
+    menuOpen,
+    menuTriggerRef,
+    markdownLink: showMarkdownLink ? /* @__PURE__ */ jsxs(
+      "a",
+      {
+        className: "inline-flex min-h-7 items-center gap-1.5 text-xs font-medium text-foreground-2 no-underline transition-colors hover:text-foreground-1 hover:underline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-focus-stroke motion-reduce:transition-none",
+        "data-slot": "agent-actions-markdown-link",
+        href: resolvedMarkdownPath,
+        children: [
+          /* @__PURE__ */ jsx(
+            MarkdownLogoIcon,
+            {
+              "aria-hidden": "true",
+              className: "size-4 shrink-0",
+              weight: "fill"
+            }
+          ),
+          /* @__PURE__ */ jsx("span", { children: markdownLinkLabel })
+        ]
+      }
+    ) : null,
+    renderPrimaryAction: (action = resolvedPrimaryAction) => {
+      let href = resolveValue(action.href, context), disabled = resolveValue(action.disabled, context), target = action.target ?? (action.openInNew ? "_blank" : void 0), rel = target === "_blank" ? mergeRel(action.rel) : void 0;
+      return href && !action.copy && !action.onSelect ? /* @__PURE__ */ jsxs(
+        "a",
+        {
+          "aria-disabled": disabled ? "true" : void 0,
+          className: cn(
+            buttonVariants({
+              iconOnly: !1,
+              size: buttonSize,
+              variant: buttonVariant
+            }),
+            disabled && "pointer-events-none opacity-50"
+          ),
+          "data-disabled": disabled ? "" : void 0,
+          href: disabled ? void 0 : href,
+          rel,
+          target,
+          children: [
+            iconForAction(action),
+            /* @__PURE__ */ jsx("span", { children: action.title })
+          ]
+        }
+      ) : /* @__PURE__ */ jsx(
+        Button,
+        {
+          disabled: !!disabled,
+          leftIcon: iconForAction(action),
+          onFocus: () => prepareAction(action),
+          onClick: () => {
+            handleAction(action);
+          },
+          onPointerDown: () => prepareAction(action),
+          onPointerEnter: () => prepareAction(action),
+          size: buttonSize,
+          variant: buttonVariant,
+          children: action.title
+        }
+      );
+    },
+    renderMenuAction: (action) => {
+      let href = resolveValue(action.href, context), disabled = resolveValue(action.disabled, context), target = action.target ?? (action.openInNew ? "_blank" : void 0), rel = target === "_blank" ? mergeRel(action.rel) : void 0, label = action.title;
+      return href && !action.copy && !action.onSelect && !disabled ? /* @__PURE__ */ jsxs(
+        MenuLinkItem,
+        {
+          closeOnClick: !0,
+          href,
+          onClick: closeMenu,
+          rel,
+          target,
+          children: [
+            action.icon ? /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "shrink-0", children: action.icon }) : null,
+            /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1 truncate", children: label })
+          ]
+        },
+        action.id
+      ) : /* @__PURE__ */ jsxs(
+        MenuItem,
+        {
+          disabled: !!disabled,
+          onFocus: () => prepareAction(action),
+          onClick: () => {
+            handleAction(action);
+          },
+          onPointerDown: () => prepareAction(action),
+          onPointerEnter: () => prepareAction(action),
+          children: [
+            action.icon ? /* @__PURE__ */ jsx("span", { "aria-hidden": "true", className: "shrink-0", children: action.icon }) : null,
+            /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1 truncate", children: label })
+          ]
+        },
+        action.id
+      );
+    },
+    resolvedActionGroups,
+    setMenuOpenState
+  };
+  return /* @__PURE__ */ jsx(AgentActionsContext.Provider, { value: contextValue, children: children ?? /* @__PURE__ */ jsx(AgentActionsDefaultLayout, { className, ...props }) });
+}
+function AgentActionsDefaultLayout({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsxs(AgentActionsToolbar, { className, ...props, children: [
+    /* @__PURE__ */ jsx(AgentActionsMarkdownLink, {}),
+    /* @__PURE__ */ jsxs(ButtonGroup, { children: [
+      /* @__PURE__ */ jsx(AgentActionsPrimaryAction, {}),
+      /* @__PURE__ */ jsx(ButtonGroupSeparator, {}),
+      /* @__PURE__ */ jsx(AgentActionsMenu, {})
+    ] }),
+    /* @__PURE__ */ jsx(AgentActionsFeedback, {})
+  ] });
+}
+function AgentActionsToolbar({
+  className,
+  ...props
+}) {
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: cn(
+        "inline-flex flex-wrap items-center gap-x-3 gap-y-2",
+        className
+      ),
+      "data-slot": "agent-actions",
+      ...props
+    }
+  );
+}
+function AgentActionsMarkdownLink() {
+  return useAgentActions().markdownLink;
+}
+function AgentActionsPrimaryAction({ action }) {
+  return useAgentActions().renderPrimaryAction(action);
+}
+function AgentActionsFeedback() {
+  let { copyFeedback } = useAgentActions();
+  return /* @__PURE__ */ jsx("span", { "aria-live": "polite", className: "sr-only", role: "status", children: copyFeedback });
+}
+function AgentActionsGroup({
+  title,
+  children
+}) {
+  return /* @__PURE__ */ jsxs(MenuGroup, { children: [
+    title ? /* @__PURE__ */ jsx(MenuGroupLabel, { children: title }) : null,
+    children
+  ] });
+}
+function AgentActionsItem({ action }) {
+  return useAgentActions().renderMenuAction(action);
+}
+function AgentActionsMenu({ children }) {
+  let {
+    buttonSize,
+    buttonVariant,
+    closeMenu,
+    menuActionsRef,
+    menuLabel,
+    menuOpen,
+    menuTriggerRef,
+    resolvedActionGroups,
+    setMenuOpenState
+  } = useAgentActions();
+  return useEffect(() => {
+    let view = menuTriggerRef.current?.ownerDocument.defaultView;
+    if (view)
+      return view.addEventListener("pagehide", closeMenu), view.addEventListener("pageshow", closeMenu), () => {
+        view.removeEventListener("pagehide", closeMenu), view.removeEventListener("pageshow", closeMenu);
+      };
+  }, [closeMenu, menuTriggerRef]), /* @__PURE__ */ jsxs(
+    Menu,
+    {
+      actionsRef: menuActionsRef,
+      modal: !1,
+      onOpenChange: setMenuOpenState,
+      open: menuOpen,
+      children: [
+        /* @__PURE__ */ jsx(
+          MenuTrigger,
+          {
+            "aria-label": menuLabel,
+            ref: menuTriggerRef,
+            className: cn(
+              buttonVariants({
+                iconOnly: !0,
+                size: buttonSize,
+                variant: buttonVariant
+              }),
+              "data-popup-open:rounded-r-button!"
+            ),
+            children: /* @__PURE__ */ jsx(CaretDownIcon, { "aria-hidden": "true", className: "size-4" })
+          }
+        ),
+        /* @__PURE__ */ jsx(MenuPortal, { children: /* @__PURE__ */ jsx(MenuPositioner, { align: "end", children: /* @__PURE__ */ jsx(MenuPopup, { className: "min-w-56", onClick: closeMenu, children: children ?? resolvedActionGroups.map((group, index) => /* @__PURE__ */ jsxs(Fragment, { children: [
+          index > 0 ? /* @__PURE__ */ jsx(MenuSeparator, {}) : null,
+          /* @__PURE__ */ jsx(AgentActionsGroup, { title: group.title, children: group.actions.map((action) => /* @__PURE__ */ jsx(AgentActionsItem, { action }, action.id)) })
+        ] }, group.id)) }) }) })
+      ]
+    }
+  );
+}
+function AgentActionsRoot(props) {
+  return /* @__PURE__ */ jsx(AgentActionsProvider, { ...props });
+}
+var AgentActions = Object.assign(AgentActionsRoot, {
+  Feedback: AgentActionsFeedback,
+  Group: AgentActionsGroup,
+  Item: AgentActionsItem,
+  MarkdownLink: AgentActionsMarkdownLink,
+  Menu: AgentActionsMenu,
+  PrimaryAction: AgentActionsPrimaryAction,
+  Root: AgentActionsRoot,
+  Toolbar: AgentActionsToolbar
+});
+export {
+  AgentActions,
+  AgentActionsFeedback as Feedback,
+  AgentActionsGroup as Group,
+  AgentActionsItem as Item,
+  AgentActionsMarkdownLink as MarkdownLink,
+  AgentActionsMenu as Menu,
+  AgentActionsPrimaryAction as PrimaryAction,
+  AgentActionsRoot as Root,
+  AgentActionsToolbar as Toolbar
+};

package/dist/components/blocks/toc.d.ts

@@ -0,0 +1,43 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+
+declare function TocDesktop({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TocMobile({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TocMobileHeader({ children }: {
+    children?: ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function TocLinksSlot({ className, listClassName, viewport, }: {
+    className?: string;
+    listClassName?: string;
+    viewport?: "desktop" | "mobile";
+}): react_jsx_runtime.JSX.Element;
+declare function TocTitle({ children, className, ...props }: React.ComponentPropsWithoutRef<"span">): react_jsx_runtime.JSX.Element;
+
+type TocProps = {
+    children?: ReactNode;
+    className?: string;
+    content?: string;
+    desktopClassName?: string;
+    desktopListClassName?: string;
+    levels?: [number, number];
+    listClassName?: string;
+    mobileClassName?: string;
+    mobileQuery?: string;
+    readingOffset?: number;
+    title?: string;
+};
+declare function TocRoot({ className, content, desktopClassName, desktopListClassName, levels, listClassName, mobileClassName, mobileQuery, readingOffset, title, children, }: TocProps): react_jsx_runtime.JSX.Element | null;
+declare const Toc: typeof TocRoot & {
+    Desktop: typeof TocDesktop;
+    Links: typeof TocLinksSlot;
+    Mobile: typeof TocMobile;
+    MobileHeader: typeof TocMobileHeader;
+    Root: typeof TocRoot;
+    Title: typeof TocTitle;
+};
+
+export { Toc, type TocProps };