@elabs-ai/components-viewer 4.2.0 → 5.0.0

package/dist/chunk-T4Y4YRHJ.js

@@ -0,0 +1,733 @@
+"use client";
+import {
+  FileViewerFind,
+  isFindShortcut
+} from "./chunk-PAIVK4N6.js";
+import {
+  FileViewerPager
+} from "./chunk-LRPZ373O.js";
+import {
+  FileViewerRotate,
+  FileViewerZoom
+} from "./chunk-PKYDKXCO.js";
+import {
+  FileViewerContext,
+  useFileViewer
+} from "./chunk-CLOI4HBA.js";
+import {
+  resolveHighlights
+} from "./chunk-FQHZEQUH.js";
+import {
+  FIND_MATCH_LIMIT,
+  findMatchId
+} from "./chunk-CO2VJRSU.js";
+import {
+  DEFAULT_ZOOM,
+  stepZoom
+} from "./chunk-SASY77ZL.js";
+import {
+  createDefaultRegistry
+} from "./chunk-QIPKBOZJ.js";
+import {
+  ViewerError,
+  isAbort,
+  isModuleNotFound,
+  parserMissingError,
+  toViewerError
+} from "./chunk-JHFC2KBI.js";
+
+// src/file-viewer/file-viewer.tsx
+import {
+  Button,
+  cn,
+  downloadBlob,
+  fileIconFor,
+  IconButton,
+  normalizeFileSource,
+  normalizeQuoteTextWithOffsets,
+  queryToRanges,
+  resolveFileKind,
+  Separator,
+  Skeleton,
+  StatePanel,
+  Text,
+  useLocale
+} from "@elabs-ai/components-ui";
+import { DownloadIcon, EyeOffIcon, SearchXIcon } from "lucide-react";
+import {
+  forwardRef,
+  useCallback,
+  useDeferredValue,
+  useEffect,
+  useMemo,
+  useRef,
+  useState
+} from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var NO_HIGHLIGHTS = [];
+var NO_RESOLVED = [];
+var NO_SUPPORT = [];
+var NO_MATCHES = { highlights: NO_HIGHLIGHTS, total: 0, truncated: false };
+function FileViewerProvider({
+  source,
+  registry: registryProp,
+  loading = false,
+  baseHeadingLevel = 2,
+  highlights: highlightsProp,
+  defaultHighlights,
+  onHighlightsChange,
+  activeHighlightId: activeHighlightIdProp,
+  defaultActiveHighlightId = null,
+  onActiveHighlightChange,
+  pageNumber: pageNumberProp,
+  defaultPageNumber = 1,
+  onPageNumberChange,
+  zoom: zoomProp,
+  defaultZoom = "fit-width",
+  onZoomChange,
+  rotation: rotationProp,
+  defaultRotation = 0,
+  onRotationChange,
+  children
+}) {
+  const fallbackRegistry = useMemo(() => createDefaultRegistry(), []);
+  const registry = registryProp ?? fallbackRegistry;
+  const [attempt, setAttempt] = useState(0);
+  const [state, setState] = useState({ status: "empty", capabilities: {} });
+  const resolved = useMemo(() => source ? normalizeFileSource(source) : void 0, [source]);
+  useEffect(() => {
+    if (!resolved) {
+      setState({ status: "empty", capabilities: {} });
+      return;
+    }
+    const controller = new AbortController();
+    let instance;
+    let cancelled = false;
+    const kind = resolveFileKind(resolved.name, resolved.mediaType);
+    const manifest = registry.detect(kind);
+    setState({
+      status: "loading",
+      source: resolved,
+      capabilities: manifest?.capabilities ?? {}
+    });
+    void (async () => {
+      try {
+        if (!manifest) {
+          throw new ViewerError("unsupported-format", `No adapter can open "${resolved.name}".`, {
+            fileName: resolved.name
+          });
+        }
+        const adapter = await registry.load(manifest.id);
+        const parser = adapter.create();
+        instance = parser;
+        const document = await parser.load(resolved, { signal: controller.signal });
+        if (cancelled) return;
+        setState({
+          status: "ready",
+          source: resolved,
+          document,
+          adapter,
+          capabilities: manifest.capabilities ?? {}
+        });
+      } catch (error) {
+        if (cancelled || isAbort(error)) return;
+        const missingPeer = isModuleNotFound(error) && manifest ? parserMissingError(manifest.id, manifest.requires ?? [], {
+          fileName: resolved.name,
+          cause: error
+        }) : void 0;
+        setState({
+          status: "error",
+          source: resolved,
+          capabilities: manifest?.capabilities ?? {},
+          error: missingPeer ?? toViewerError(error, "parse-failed", { fileName: resolved.name })
+        });
+      }
+    })();
+    return () => {
+      cancelled = true;
+      controller.abort();
+      instance?.dispose?.();
+      resolved.revoke();
+    };
+  }, [resolved, registry, attempt]);
+  const highlightsControlled = highlightsProp !== void 0;
+  const [ownHighlights, setOwnHighlights] = useState(defaultHighlights ?? NO_HIGHLIGHTS);
+  const highlights = highlightsControlled ? highlightsProp : ownHighlights;
+  const setHighlights = useCallback(
+    (next) => {
+      if (!highlightsControlled) setOwnHighlights(next);
+      onHighlightsChange?.(next);
+    },
+    [highlightsControlled, onHighlightsChange]
+  );
+  const activeControlled = activeHighlightIdProp !== void 0;
+  const [ownActiveId, setOwnActiveId] = useState(defaultActiveHighlightId);
+  const activeHighlightId = activeControlled ? activeHighlightIdProp : ownActiveId;
+  const setActiveHighlight = useCallback(
+    (id) => {
+      if (!activeControlled) setOwnActiveId(id);
+      onActiveHighlightChange?.(id);
+    },
+    [activeControlled, onActiveHighlightChange]
+  );
+  const pageCount = state.document?.pageCount ?? 0;
+  const pageControlled = pageNumberProp !== void 0;
+  const [ownPage, setOwnPage] = useState(defaultPageNumber);
+  const rawPage = pageControlled ? pageNumberProp : ownPage;
+  const pageNumber = pageCount > 0 ? Math.min(Math.max(1, rawPage), pageCount) : Math.max(1, rawPage);
+  const goToPage = useCallback(
+    (page) => {
+      const next = Math.max(1, Math.round(page));
+      if (!pageControlled) setOwnPage(next);
+      onPageNumberChange?.(next);
+    },
+    [pageControlled, onPageNumberChange]
+  );
+  const zoomControlled = zoomProp !== void 0;
+  const [ownZoom, setOwnZoom] = useState(defaultZoom);
+  const zoom = zoomControlled ? zoomProp : ownZoom;
+  const setZoom = useCallback(
+    (next) => {
+      if (!zoomControlled) setOwnZoom(next);
+      onZoomChange?.(next);
+    },
+    [zoomControlled, onZoomChange]
+  );
+  const [reportedZoom, setReportedZoom] = useState(DEFAULT_ZOOM);
+  const effectiveZoom = typeof zoom === "number" ? zoom : reportedZoom;
+  const rotationControlled = rotationProp !== void 0;
+  const [ownRotation, setOwnRotation] = useState(defaultRotation);
+  const rotation = rotationControlled ? rotationProp : ownRotation;
+  const setRotation = useCallback(
+    (next) => {
+      if (!rotationControlled) setOwnRotation(next);
+      onRotationChange?.(next);
+    },
+    [rotationControlled, onRotationChange]
+  );
+  const previousSource = useRef(resolved);
+  useEffect(() => {
+    if (previousSource.current === resolved) return;
+    previousSource.current = resolved;
+    setOwnPage(1);
+    setOwnRotation(0);
+  }, [resolved]);
+  const [find, setFind] = useState({
+    open: false,
+    query: "",
+    caseSensitive: false,
+    activeIndex: 0
+  });
+  const [findParts, setFindParts] = useState(0);
+  const registerFind = useCallback(() => {
+    setFindParts((count) => count + 1);
+    return () => setFindParts((count) => count - 1);
+  }, []);
+  const text = state.document?.text;
+  const capabilities = state.capabilities;
+  const support = capabilities.highlight ?? NO_SUPPORT;
+  const canFind = (capabilities.search ?? true) && text !== void 0 && support.includes("range");
+  const query = useDeferredValue(find.query);
+  const findMatches = useMemo(() => {
+    if (!find.open || !canFind || text === void 0 || query.length === 0) return NO_MATCHES;
+    const ranges = queryToRanges(text, query, find.caseSensitive);
+    return {
+      highlights: ranges.slice(0, FIND_MATCH_LIMIT).map(([start, end], index) => ({
+        id: findMatchId(index),
+        address: { kind: "range", start, end },
+        source: "search"
+      })),
+      total: ranges.length,
+      truncated: ranges.length > FIND_MATCH_LIMIT
+    };
+  }, [find.open, find.caseSensitive, canFind, text, query]);
+  const normalized = useMemo(
+    () => text === void 0 ? void 0 : normalizeQuoteTextWithOffsets(text),
+    [text]
+  );
+  const activeFindId = find.open && findMatches.highlights.length > 0 ? findMatchId(find.activeIndex) : void 0;
+  const currentHighlightId = activeFindId ?? activeHighlightId;
+  const resolvedHighlights = useMemo(() => {
+    if (highlights.length === 0 && findMatches.highlights.length === 0) return NO_RESOLVED;
+    return resolveHighlights([...highlights, ...findMatches.highlights], {
+      normalized,
+      textLength: text?.length,
+      truncated: state.document?.textTruncated,
+      supported: support,
+      activeId: currentHighlightId
+    });
+  }, [
+    highlights,
+    findMatches.highlights,
+    normalized,
+    text?.length,
+    state.document?.textTruncated,
+    support,
+    currentHighlightId
+  ]);
+  const stepCitation = useCallback(
+    (delta) => {
+      const list = resolvedHighlights.filter(
+        (highlight) => highlight.source === "citation" && highlight.status === "resolved"
+      );
+      if (list.length === 0) return;
+      const at = list.findIndex((highlight) => highlight.id === activeHighlightId);
+      const to = at === -1 ? delta === 1 ? 0 : list.length - 1 : (at + delta + list.length) % list.length;
+      setActiveHighlight(list[to].id);
+    },
+    [resolvedHighlights, activeHighlightId, setActiveHighlight]
+  );
+  const stepFind = useCallback(
+    (delta) => {
+      const count = findMatches.highlights.length;
+      if (count === 0) return;
+      setFind((current) => ({
+        ...current,
+        activeIndex: (current.activeIndex + delta + count) % count
+      }));
+    },
+    [findMatches.highlights.length]
+  );
+  const findState = useMemo(
+    () => ({
+      open: find.open,
+      query: find.query,
+      caseSensitive: find.caseSensitive,
+      matches: findMatches.total,
+      truncated: findMatches.truncated,
+      activeIndex: find.activeIndex
+    }),
+    [find, findMatches.total, findMatches.truncated]
+  );
+  const actions = useMemo(
+    () => ({
+      reload: () => setAttempt((n) => n + 1),
+      setHighlights,
+      setActiveHighlight,
+      nextHighlight: () => stepCitation(1),
+      previousHighlight: () => stepCitation(-1),
+      openFind: () => setFind((current) => ({ ...current, open: true })),
+      // The query survives a close, so re-opening resumes where the reader was;
+      // only the box goes away.
+      closeFind: () => setFind((current) => ({ ...current, open: false })),
+      setFindQuery: (next) => setFind((current) => ({ ...current, query: next, activeIndex: 0 })),
+      setFindCaseSensitive: (next) => setFind((current) => ({ ...current, caseSensitive: next, activeIndex: 0 })),
+      nextFindMatch: () => stepFind(1),
+      previousFindMatch: () => stepFind(-1),
+      goToPage,
+      // Stop at the ends rather than wrap: a document is not a carousel, and a
+      // reader who holds "next" past the last page expects to stay there.
+      nextPage: () => goToPage(Math.min(pageNumber + 1, pageCount || pageNumber + 1)),
+      previousPage: () => goToPage(pageNumber - 1),
+      setZoom,
+      // Stepping from `effectiveZoom`, not from `zoom`: after a fit the ladder
+      // has to continue from what is actually on screen.
+      zoomIn: () => setZoom(stepZoom(effectiveZoom, 1)),
+      zoomOut: () => setZoom(stepZoom(effectiveZoom, -1)),
+      setRotation,
+      rotate: (quarterTurns) => setRotation(((rotation + quarterTurns * 90) % 360 + 360) % 360),
+      reportZoom: setReportedZoom,
+      registerFind
+    }),
+    [
+      setHighlights,
+      setActiveHighlight,
+      stepCitation,
+      stepFind,
+      registerFind,
+      goToPage,
+      pageNumber,
+      pageCount,
+      setZoom,
+      effectiveZoom,
+      setRotation,
+      rotation
+    ]
+  );
+  const value = useMemo(
+    () => ({
+      state: {
+        // A parent's `loading` can add the not-ready state but never clear a
+        // real error — losing a failure to a stale prop is worse than a late
+        // spinner.
+        ...loading && state.status !== "error" ? { ...state, status: "loading" } : state,
+        highlights,
+        activeHighlightId,
+        find: findState,
+        pageNumber,
+        pageCount,
+        zoom,
+        effectiveZoom,
+        rotation
+      },
+      actions,
+      registry,
+      meta: {
+        baseHeadingLevel,
+        resolvedHighlights,
+        currentHighlightId,
+        highlightSupport: support,
+        canFind,
+        hasFind: findParts > 0
+      }
+    }),
+    [
+      state,
+      loading,
+      registry,
+      baseHeadingLevel,
+      highlights,
+      activeHighlightId,
+      findState,
+      actions,
+      resolvedHighlights,
+      currentHighlightId,
+      support,
+      canFind,
+      findParts,
+      pageNumber,
+      pageCount,
+      zoom,
+      effectiveZoom,
+      rotation
+    ]
+  );
+  return /* @__PURE__ */ jsx(FileViewerContext, { value, children });
+}
+var FileViewerFrame = forwardRef(
+  function FileViewerFrame2({ className, children, onKeyDown, ...props }, ref) {
+    const { state, actions, meta } = useFileViewer();
+    const { t } = useLocale();
+    const frame = useRef(null);
+    const wasOpen = useRef(false);
+    const findOpen = state.find.open && meta.canFind;
+    useEffect(() => {
+      if (wasOpen.current && !findOpen) {
+        frame.current?.querySelector('[data-slot="file-viewer-content"]')?.focus({ preventScroll: true });
+      }
+      wasOpen.current = findOpen;
+    }, [findOpen]);
+    return /* @__PURE__ */ jsx(
+      "section",
+      {
+        ref: (node) => {
+          frame.current = node;
+          if (typeof ref === "function") ref(node);
+          else if (ref) ref.current = node;
+        },
+        "data-slot": "file-viewer",
+        "aria-label": t("viewer.label"),
+        className: cn(
+          "bg-card text-card-foreground border-border flex h-full min-h-0 flex-col overflow-hidden rounded-lg border shadow-sm",
+          className
+        ),
+        onKeyDown: (event) => {
+          onKeyDown?.(event);
+          if (!event.defaultPrevented && meta.canFind && meta.hasFind && isFindShortcut(event)) {
+            event.preventDefault();
+            actions.openFind();
+          }
+        },
+        ...props,
+        children
+      }
+    );
+  }
+);
+var FileViewerToolbar = forwardRef(
+  function FileViewerToolbar2({ className, actions, children, ...props }, ref) {
+    const { state } = useFileViewer();
+    const { t } = useLocale();
+    const source = state.source;
+    const Glyph = fileIconFor(source?.name ?? "", source?.mediaType);
+    const [downloadFailed, setDownloadFailed] = useState(false);
+    if (!source) return null;
+    const download = () => {
+      setDownloadFailed(false);
+      void source.bytes().then((bytes) => {
+        downloadBlob(new Blob([bytes], { type: source.mediaType }), source.name);
+      }).catch((error) => {
+        console.error("FileViewer: download failed", error);
+        setDownloadFailed(true);
+      });
+    };
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-toolbar",
+        className: cn(
+          // The divider is the ONLY cue between toolbar and content (same fill,
+          // no elevation change) — WCAG 1.4.11, so the strong rung.
+          "border-border-strong flex shrink-0 items-center gap-2 border-b px-3 py-2",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx(Glyph, { "aria-hidden": "true", className: "text-muted-foreground size-4 shrink-0" }),
+          /* @__PURE__ */ jsx(Text, { className: "min-w-0 flex-1 truncate", title: source.name, children: source.name }),
+          children,
+          actions,
+          downloadFailed ? /* @__PURE__ */ jsx(Text, { role: "alert", className: "text-destructive-text shrink-0 truncate", children: t("viewer.error.readFailedBody", { name: source.name, format: source.mediaType }) }) : null,
+          /* @__PURE__ */ jsx(Separator, { orientation: "vertical", className: "h-4" }),
+          /* @__PURE__ */ jsx(
+            IconButton,
+            {
+              variant: "ghost",
+              label: t("viewer.download", { name: source.name }),
+              icon: /* @__PURE__ */ jsx(DownloadIcon, { "aria-hidden": "true" }),
+              onClick: download
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+var FileViewerHighlightStatus = forwardRef(
+  function FileViewerHighlightStatus2({ className, ...props }, ref) {
+    const { state, meta } = useFileViewer();
+    const { t } = useLocale();
+    const missed = meta.resolvedHighlights.filter(
+      (highlight) => highlight.source === "citation" && (highlight.status === "not-found" || highlight.status === "unsupported")
+    );
+    if (missed.length === 0) return null;
+    const first = missed[0];
+    const message = first.status === "unsupported" ? t("viewer.highlight.unsupported", {
+      format: state.source?.extension.toUpperCase() || ""
+    }) : first.reason === "truncated" ? t("viewer.highlight.notFoundTruncated") : t("viewer.highlight.notFound");
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-highlight-status",
+        role: "status",
+        "aria-live": "polite",
+        className: cn(
+          // Information, not a failure — a neutral muted row, never the
+          // destructive tone. The divider is the sole cue between it and the
+          // content below (WCAG 1.4.11, strong rung).
+          "border-border-strong text-muted-foreground flex shrink-0 items-center gap-2 border-b px-3 py-2",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx(SearchXIcon, { "aria-hidden": "true", className: "size-4 shrink-0" }),
+          /* @__PURE__ */ jsx("span", { className: "text-meta min-w-0 flex-1 truncate", children: message })
+        ]
+      }
+    );
+  }
+);
+var FileViewerSkeleton = forwardRef(
+  function FileViewerSkeleton2({ className, ...props }, ref) {
+    const { state } = useFileViewer();
+    const { t } = useLocale();
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-skeleton",
+        role: "status",
+        "aria-live": "polite",
+        className: cn("flex h-full flex-col gap-3 p-4", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx("span", { className: "sr-only", children: t("viewer.loading", { name: state.source?.name ?? "" }) }),
+          /* @__PURE__ */ jsx(Skeleton, { "aria-hidden": "true", className: "h-4 w-2/5" }),
+          /* @__PURE__ */ jsx(Skeleton, { "aria-hidden": "true", className: "h-4 w-4/5" }),
+          /* @__PURE__ */ jsx(Skeleton, { "aria-hidden": "true", className: "h-4 w-3/5" }),
+          /* @__PURE__ */ jsx(Skeleton, { "aria-hidden": "true", className: "min-h-24 flex-1" })
+        ]
+      }
+    );
+  }
+);
+var ERROR_MESSAGES = {
+  "unsupported-format": {
+    title: "viewer.error.unsupportedFormat",
+    body: "viewer.error.unsupportedFormatBody"
+  },
+  "parser-missing": {
+    title: "viewer.error.parserMissing",
+    body: "viewer.error.parserMissingBody"
+  },
+  "read-failed": { title: "viewer.error.readFailed", body: "viewer.error.readFailedBody" },
+  "parse-failed": { title: "viewer.error.parseFailed", body: "viewer.error.parseFailedBody" },
+  // Neither should ever reach the UI: a protocol mismatch throws at registration
+  // and an abort is swallowed as a superseded load. Mapped anyway so the panel
+  // can never render an empty title.
+  "protocol-mismatch": { title: "viewer.error.parseFailed", body: "viewer.error.parseFailedBody" },
+  aborted: { title: "viewer.error.readFailed", body: "viewer.error.readFailedBody" }
+};
+var CAPABILITY_GAPS = /* @__PURE__ */ new Set(["unsupported-format", "parser-missing"]);
+var FileViewerError = forwardRef(
+  function FileViewerError2({ className, ...props }, ref) {
+    const { state } = useFileViewer();
+    const { t } = useLocale();
+    const error = state.error;
+    if (!error) return null;
+    const message = ERROR_MESSAGES[error.code];
+    const vars = {
+      name: state.source?.name ?? "",
+      format: state.source?.extension.toUpperCase() || t("viewer.error.parseFailed"),
+      packages: error.packages?.join(", ") ?? ""
+    };
+    const isGap = CAPABILITY_GAPS.has(error.code);
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-error",
+        className: cn("flex min-h-full flex-col justify-center p-4", className),
+        ...isGap ? { role: "status", "aria-live": "polite" } : {},
+        ...props,
+        children: /* @__PURE__ */ jsx(
+          StatePanel,
+          {
+            kind: isGap ? "empty" : "error",
+            className: isGap ? "border-solid" : void 0,
+            icon: isGap ? /* @__PURE__ */ jsx(EyeOffIcon, { "aria-hidden": "true" }) : void 0,
+            title: t(message.title),
+            description: t(message.body, vars),
+            actions: error.code === "read-failed" || error.code === "parse-failed" ? /* @__PURE__ */ jsx(RetryButton, {}) : void 0
+          }
+        )
+      }
+    );
+  }
+);
+function RetryButton() {
+  const { actions } = useFileViewer();
+  const { t } = useLocale();
+  return /* @__PURE__ */ jsx(Button, { variant: "outline", size: "sm", onClick: actions.reload, children: t("viewer.retry") });
+}
+var FileViewerEmpty = forwardRef(
+  function FileViewerEmpty2({ className, ...props }, ref) {
+    const { t } = useLocale();
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-empty",
+        className: cn("flex min-h-full flex-col justify-center p-4", className),
+        ...props,
+        children: /* @__PURE__ */ jsx(StatePanel, { kind: "empty", title: t("viewer.empty"), description: t("viewer.emptyBody") })
+      }
+    );
+  }
+);
+var FileViewerContent = forwardRef(
+  function FileViewerContent2({ className, ...props }, ref) {
+    const { state, actions, meta } = useFileViewer();
+    const { t } = useLocale();
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-content",
+        role: "region",
+        "aria-label": t("viewer.content"),
+        tabIndex: 0,
+        className: cn("focus-ring min-h-0 flex-1 overflow-auto p-4", className),
+        ...props,
+        children: [
+          state.status === "empty" && /* @__PURE__ */ jsx(FileViewerEmpty, {}),
+          state.status === "loading" && /* @__PURE__ */ jsx(FileViewerSkeleton, {}),
+          state.status === "error" && /* @__PURE__ */ jsx(FileViewerError, {}),
+          state.status === "ready" && state.adapter && state.document && state.source && /* @__PURE__ */ jsx(
+            state.adapter.Renderer,
+            {
+              document: state.document,
+              source: state.source,
+              baseHeadingLevel: meta.baseHeadingLevel,
+              highlights: meta.resolvedHighlights,
+              activeHighlightId: meta.currentHighlightId,
+              pageNumber: state.pageNumber,
+              onPageChange: actions.goToPage,
+              zoom: state.zoom,
+              onZoomResolved: actions.reportZoom,
+              rotation: state.rotation
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+var FileViewer = forwardRef(function FileViewer2({
+  // Every provider prop is destructured BY NAME, and the rest goes to the
+  // frame. Peeling off only some of them and spreading the remainder was a
+  // silent bug: `baseHeadingLevel` type-checked, never reached the provider,
+  // and landed on the `<section>` as an unknown DOM attribute. Adding a
+  // provider prop above without adding it here re-creates that exactly.
+  source,
+  registry,
+  loading,
+  baseHeadingLevel,
+  highlights,
+  defaultHighlights,
+  onHighlightsChange,
+  activeHighlightId,
+  defaultActiveHighlightId,
+  onActiveHighlightChange,
+  pageNumber,
+  defaultPageNumber,
+  onPageNumberChange,
+  zoom,
+  defaultZoom,
+  onZoomChange,
+  rotation,
+  defaultRotation,
+  onRotationChange,
+  children,
+  ...props
+}, ref) {
+  return /* @__PURE__ */ jsx(
+    FileViewerProvider,
+    {
+      source,
+      registry,
+      loading,
+      baseHeadingLevel,
+      highlights,
+      defaultHighlights,
+      onHighlightsChange,
+      activeHighlightId,
+      defaultActiveHighlightId,
+      onActiveHighlightChange,
+      pageNumber,
+      defaultPageNumber,
+      onPageNumberChange,
+      zoom,
+      defaultZoom,
+      onZoomChange,
+      rotation,
+      defaultRotation,
+      onRotationChange,
+      children: /* @__PURE__ */ jsx(FileViewerFrame, { ref, ...props, children: children ?? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsxs(FileViewerToolbar, { children: [
+          /* @__PURE__ */ jsx(FileViewerPager, {}),
+          /* @__PURE__ */ jsx(FileViewerZoom, {}),
+          /* @__PURE__ */ jsx(FileViewerRotate, {})
+        ] }),
+        /* @__PURE__ */ jsx(FileViewerFind, {}),
+        /* @__PURE__ */ jsx(FileViewerHighlightStatus, {}),
+        /* @__PURE__ */ jsx(FileViewerContent, {})
+      ] }) })
+    }
+  );
+});
+
+export {
+  FileViewerProvider,
+  FileViewerFrame,
+  FileViewerToolbar,
+  FileViewerHighlightStatus,
+  FileViewerSkeleton,
+  FileViewerError,
+  FileViewerEmpty,
+  FileViewerContent,
+  FileViewer
+};
+//# sourceMappingURL=chunk-T4Y4YRHJ.js.map