@elabs-ai/components-viewer 4.0.0

package/dist/index.js

@@ -0,0 +1,1364 @@
+"use client";
+import {
+  pptxManifest
+} from "./chunk-KOMDRWOU.js";
+import {
+  markdownManifest
+} from "./chunk-H3OAON3D.js";
+import {
+  codeManifest
+} from "./chunk-5OMONA2G.js";
+import {
+  textManifest
+} from "./chunk-UJIJECEF.js";
+import {
+  imageManifest
+} from "./chunk-GGR7BNW4.js";
+import {
+  jsonManifest
+} from "./chunk-BCF3RWRL.js";
+import {
+  csvManifest
+} from "./chunk-3U3MESBU.js";
+import {
+  DEFAULT_ZOOM,
+  VIEWER_ZOOM_STEPS,
+  canStepZoom,
+  configurePdfEngine,
+  getPdfEngineConfig,
+  isZoomFit,
+  pdfManifest,
+  stepZoom
+} from "./chunk-SLXRUYT3.js";
+import {
+  mediaManifest
+} from "./chunk-HMG2ERXH.js";
+import {
+  docxManifest
+} from "./chunk-FELIAGKI.js";
+import {
+  xlsxManifest
+} from "./chunk-RGWDIQJR.js";
+import {
+  chunkOffset,
+  createTextIndexBuilder,
+  spanAt,
+  spansForRange
+} from "./chunk-UL43NGUG.js";
+import {
+  ACTIVE_HIGHLIGHT_SELECTOR,
+  localizeRanges,
+  toMarkRanges,
+  useScrollActiveHighlightIntoView
+} from "./chunk-VO2273Z2.js";
+import {
+  PROTOCOL_VERSION,
+  ViewerError,
+  isAbort,
+  isModuleNotFound,
+  isViewerError,
+  parserMissingError,
+  toViewerError
+} from "./chunk-AORNMH77.js";
+
+// src/file-viewer/file-viewer.tsx
+import {
+  Button,
+  cn as cn4,
+  downloadBlob,
+  fileIconFor,
+  IconButton as IconButton4,
+  normalizeFileSource,
+  normalizeQuoteTextWithOffsets,
+  queryToRanges,
+  resolveFileKind as resolveFileKind2,
+  Separator as Separator2,
+  Skeleton,
+  StatePanel,
+  Text,
+  useLocale as useLocale4
+} from "@elabs-ai/components-ui";
+import { DownloadIcon, EyeOffIcon, SearchXIcon } from "lucide-react";
+import {
+  forwardRef as forwardRef4,
+  useCallback,
+  useDeferredValue,
+  useEffect as useEffect2,
+  useMemo,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+
+// src/core/registry.ts
+import { resolveFileKind } from "@elabs-ai/components-ui";
+var MatchScore = {
+  None: 0,
+  Category: 1,
+  MediaTypePrefix: 2,
+  MediaType: 3,
+  Extension: 4
+};
+function scoreManifest(manifest, kind) {
+  if (kind.extension && manifest.extensions?.includes(kind.extension)) {
+    return MatchScore.Extension;
+  }
+  for (const declared of manifest.mediaTypes ?? []) {
+    if (declared.endsWith("/")) {
+      if (kind.mediaType.startsWith(declared)) return MatchScore.MediaTypePrefix;
+    } else if (declared === kind.mediaType) {
+      return MatchScore.MediaType;
+    }
+  }
+  if (manifest.categories?.includes(kind.category)) return MatchScore.Category;
+  return MatchScore.None;
+}
+function unwrap(loaded) {
+  return "default" in loaded && loaded.default ? loaded.default : loaded;
+}
+function assertProtocol(manifest, where) {
+  if (manifest.protocol !== PROTOCOL_VERSION) {
+    throw new ViewerError(
+      "protocol-mismatch",
+      `Adapter "${manifest.id}" targets viewer protocol ${String(manifest.protocol)}, but this build speaks ${String(PROTOCOL_VERSION)} (${where}).`
+    );
+  }
+}
+function createRegistry() {
+  const entries = /* @__PURE__ */ new Map();
+  const modules = /* @__PURE__ */ new Map();
+  function ordered() {
+    return [...entries.values()].sort(
+      (a, b) => (b.manifest.priority ?? 0) - (a.manifest.priority ?? 0)
+    );
+  }
+  function detect(kind) {
+    let best;
+    for (const { manifest } of entries.values()) {
+      const score = scoreManifest(manifest, kind);
+      if (score === MatchScore.None) continue;
+      const priority = manifest.priority ?? 0;
+      const wins = !best || priority > best.priority || priority === best.priority && score > best.score;
+      if (wins) best = { manifest, score, priority };
+    }
+    return best?.manifest;
+  }
+  return {
+    register(manifest, loader) {
+      assertProtocol(manifest, "registration");
+      entries.set(manifest.id, { manifest, loader });
+      modules.delete(manifest.id);
+    },
+    manifests() {
+      return ordered().map((entry) => entry.manifest);
+    },
+    detect,
+    detectByName(name, mediaType) {
+      return detect(resolveFileKind(name, mediaType));
+    },
+    async load(id) {
+      const entry = entries.get(id);
+      if (!entry) {
+        throw new ViewerError("unsupported-format", `No adapter is registered for "${id}".`);
+      }
+      let pending = modules.get(id);
+      if (!pending) {
+        pending = entry.loader().then((loaded) => {
+          const adapterModule = unwrap(loaded);
+          assertProtocol(adapterModule.manifest, `module "${id}"`);
+          return adapterModule;
+        }).catch((error) => {
+          modules.delete(id);
+          if (isModuleNotFound(error)) {
+            throw parserMissingError(id, entry.manifest.requires ?? [], { cause: error });
+          }
+          throw toViewerError(error, "parse-failed");
+        });
+        modules.set(id, pending);
+      }
+      return pending;
+    }
+  };
+}
+
+// src/adapters/index.ts
+function createDefaultRegistry() {
+  const registry = createRegistry();
+  registry.register(imageManifest, () => import("./image-adapter-WOHZR24J.js"));
+  registry.register(jsonManifest, () => import("./json-adapter-ZUW5GQHE.js"));
+  registry.register(csvManifest, () => import("./csv-adapter-6VU3FFVU.js"));
+  registry.register(pdfManifest, () => import("./pdf-adapter-5PMKEXUD.js"));
+  registry.register(mediaManifest, () => import("./media-adapter-MCTB4GBH.js"));
+  registry.register(docxManifest, () => import("./docx-adapter-5CQDHWTD.js"));
+  registry.register(xlsxManifest, () => import("./xlsx-adapter-CM2Y6AKQ.js"));
+  registry.register(pptxManifest, () => import("./pptx-adapter-6GEQLS2Z.js"));
+  registry.register(markdownManifest, () => import("./markdown-adapter-YC6WTBS4.js"));
+  registry.register(codeManifest, () => import("./code-adapter-ADZ4UOGN.js"));
+  registry.register(textManifest, () => import("./text-adapter-NFNWB5W3.js"));
+  return registry;
+}
+
+// src/core/highlight.ts
+var FIND_MATCH_LIMIT = 2e3;
+var FIND_ID_PREFIX = "find:";
+function findMatchId(index) {
+  return `${FIND_ID_PREFIX}${String(index)}`;
+}
+function isFindMatchId(id) {
+  return id.startsWith(FIND_ID_PREFIX);
+}
+
+// src/core/highlight-resolve.ts
+import {
+  normalizeQuoteText
+} from "@elabs-ai/components-ui";
+function locateQuote(normalized, address) {
+  const needle = normalizeQuoteText(address.text);
+  if (needle.length === 0) return void 0;
+  const starts = [];
+  for (let at = normalized.text.indexOf(needle); at !== -1; ) {
+    starts.push(at);
+    at = normalized.text.indexOf(needle, at + 1);
+  }
+  if (starts.length === 0) return void 0;
+  const toRange = (start) => [
+    normalized.offsets[start],
+    normalized.offsets[start + needle.length]
+  ];
+  if (address.occurrence !== void 0) {
+    const chosen = starts[address.occurrence - 1];
+    return chosen === void 0 ? void 0 : toRange(chosen);
+  }
+  const near = address.near?.offset;
+  if (near !== void 0) {
+    let best = starts[0];
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (const start of starts) {
+      const distance = Math.abs(normalized.offsets[start] - near);
+      if (distance < bestDistance) {
+        bestDistance = distance;
+        best = start;
+      }
+    }
+    return toRange(best);
+  }
+  return toRange(starts[0]);
+}
+function positionOf(highlight) {
+  if (highlight.range) return highlight.range[0];
+  if (highlight.page !== void 0) return highlight.page;
+  return Number.POSITIVE_INFINITY;
+}
+function resolveOne(highlight, context) {
+  const source = highlight.source ?? "citation";
+  const address = highlight.address;
+  const base = { id: highlight.id, label: highlight.label, source, address, active: false };
+  if (!context.supported.includes(address.kind)) {
+    return { ...base, status: "unsupported" };
+  }
+  if (address.kind === "rect") {
+    return { ...base, status: "resolved", page: address.page, rects: address.rects };
+  }
+  const miss = () => ({
+    ...base,
+    status: "not-found",
+    reason: context.truncated ? "truncated" : "absent"
+  });
+  if (address.kind === "range") {
+    const length = context.textLength;
+    if (length === void 0) return miss();
+    const start = Math.max(0, Math.min(address.start, length));
+    const end = Math.max(start, Math.min(address.end, length));
+    if (end === start) return miss();
+    return { ...base, status: "resolved", range: [start, end] };
+  }
+  if (!context.normalized) return miss();
+  const range = locateQuote(context.normalized, address);
+  if (!range) return miss();
+  return { ...base, status: "resolved", range };
+}
+function resolveHighlights(highlights, context) {
+  const resolved = highlights.map((highlight) => resolveOne(highlight, context)).sort((a, b) => positionOf(a) - positionOf(b));
+  const counters = /* @__PURE__ */ new Map();
+  return resolved.map((highlight) => {
+    const next = highlight.status === "resolved" ? (counters.get(highlight.source) ?? 0) + 1 : void 0;
+    if (next !== void 0) counters.set(highlight.source, next);
+    return {
+      ...highlight,
+      index: next,
+      active: context.activeId != null && context.activeId === highlight.id
+    };
+  });
+}
+
+// src/file-viewer/file-viewer-find.tsx
+import {
+  cn,
+  IconButton,
+  InputGroup,
+  InputGroupAddon,
+  InputGroupButton,
+  InputGroupInput,
+  Separator,
+  useLocale
+} from "@elabs-ai/components-ui";
+import { CaseSensitiveIcon, ChevronDownIcon, ChevronUpIcon, SearchIcon, XIcon } from "lucide-react";
+import {
+  forwardRef,
+  useEffect,
+  useRef
+} from "react";
+
+// src/file-viewer/file-viewer-context.tsx
+import { createContext, use } from "react";
+var FileViewerContext = createContext(null);
+function useFileViewer() {
+  const value = use(FileViewerContext);
+  if (!value) {
+    throw new Error("useFileViewer must be used inside a <FileViewerProvider> (or <FileViewer>).");
+  }
+  return value;
+}
+
+// src/file-viewer/file-viewer-find.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function isFindShortcut(event) {
+  return event.key.toLowerCase() === "f" && (event.metaKey || event.ctrlKey);
+}
+var FileViewerFind = forwardRef(
+  function FileViewerFind2({ className, ...props }, ref) {
+    const { state, actions, meta } = useFileViewer();
+    const { t, formatNumber } = useLocale();
+    const input = useRef(null);
+    const find = state.find;
+    const open = find.open && meta.canFind;
+    const { registerFind } = actions;
+    useEffect(() => registerFind(), [registerFind]);
+    useEffect(() => {
+      if (open) input.current?.focus();
+    }, [open]);
+    if (!open) return null;
+    const hasQuery = find.query.length > 0;
+    const hasMatches = find.matches > 0;
+    const onKeyDown = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        event.stopPropagation();
+        actions.closeFind();
+        return;
+      }
+      if (event.key === "Enter") {
+        event.preventDefault();
+        if (event.shiftKey) actions.previousFindMatch();
+        else actions.nextFindMatch();
+      }
+    };
+    return /* @__PURE__ */ jsxs(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-find",
+        role: "search",
+        "aria-label": t("viewer.find.label"),
+        className: cn(
+          // The divider is the only cue between this row and the content below
+          // it — same fill, no elevation change (WCAG 1.4.11, strong rung).
+          "border-border-strong flex shrink-0 items-center gap-2 border-b px-3 py-2",
+          className
+        ),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsxs(InputGroup, { className: "h-8 max-w-72", children: [
+            /* @__PURE__ */ jsx(InputGroupAddon, { children: /* @__PURE__ */ jsx(SearchIcon, { "aria-hidden": "true" }) }),
+            /* @__PURE__ */ jsx(
+              InputGroupInput,
+              {
+                ref: input,
+                type: "text",
+                value: find.query,
+                "aria-label": t("viewer.find.label"),
+                placeholder: t("viewer.find.placeholder"),
+                autoComplete: "off",
+                spellCheck: false,
+                onChange: (event) => actions.setFindQuery(event.target.value),
+                onKeyDown
+              }
+            ),
+            /* @__PURE__ */ jsx(InputGroupAddon, { align: "inline-end", children: /* @__PURE__ */ jsx(
+              InputGroupButton,
+              {
+                size: "icon-xs",
+                "aria-pressed": find.caseSensitive,
+                "aria-label": t("viewer.find.caseSensitive"),
+                title: t("viewer.find.caseSensitive"),
+                onClick: () => actions.setFindCaseSensitive(!find.caseSensitive),
+                children: /* @__PURE__ */ jsx(CaseSensitiveIcon, { "aria-hidden": "true" })
+              }
+            ) })
+          ] }),
+          /* @__PURE__ */ jsxs(
+            "span",
+            {
+              role: "status",
+              "aria-live": "polite",
+              className: "text-meta text-muted-foreground min-w-0 flex-1 truncate tabular-nums",
+              children: [
+                !hasQuery ? null : hasMatches ? t("viewer.find.count", {
+                  index: formatNumber(find.activeIndex + 1),
+                  total: formatNumber(Math.min(find.matches, FIND_MATCH_LIMIT))
+                }) : t("viewer.find.none"),
+                find.truncated ? ` ${t("viewer.find.capped", {
+                  limit: formatNumber(FIND_MATCH_LIMIT),
+                  total: formatNumber(find.matches)
+                })}` : null
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            IconButton,
+            {
+              variant: "ghost",
+              size: "icon-sm",
+              "aria-disabled": !hasMatches,
+              label: t("viewer.find.previous"),
+              icon: /* @__PURE__ */ jsx(ChevronUpIcon, { "aria-hidden": "true" }),
+              onClick: actions.previousFindMatch
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            IconButton,
+            {
+              variant: "ghost",
+              size: "icon-sm",
+              "aria-disabled": !hasMatches,
+              label: t("viewer.find.next"),
+              icon: /* @__PURE__ */ jsx(ChevronDownIcon, { "aria-hidden": "true" }),
+              onClick: actions.nextFindMatch
+            }
+          ),
+          /* @__PURE__ */ jsx(Separator, { orientation: "vertical", className: "h-4" }),
+          /* @__PURE__ */ jsx(
+            IconButton,
+            {
+              variant: "ghost",
+              size: "icon-sm",
+              label: t("viewer.find.close"),
+              icon: /* @__PURE__ */ jsx(XIcon, { "aria-hidden": "true" }),
+              onClick: actions.closeFind
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+
+// src/file-viewer/file-viewer-pager.tsx
+import { cn as cn2, IconButton as IconButton2, Input, useLocale as useLocale2 } from "@elabs-ai/components-ui";
+import { ChevronLeftIcon, ChevronRightIcon } from "lucide-react";
+import { forwardRef as forwardRef2, useState } from "react";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var FileViewerPager = forwardRef2(
+  function FileViewerPager2({ className, ...props }, ref) {
+    const { state, actions } = useFileViewer();
+    const { t, formatNumber } = useLocale2();
+    const [draft, setDraft] = useState(null);
+    const { pageNumber, pageCount } = state;
+    if (!state.capabilities.pages || pageCount === 0) return null;
+    const commit = () => {
+      if (draft === null) return;
+      const parsed = Number.parseInt(draft, 10);
+      setDraft(null);
+      if (Number.isNaN(parsed)) return;
+      actions.goToPage(parsed);
+    };
+    return /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-pager",
+        role: "group",
+        "aria-label": t("viewer.pager.controls"),
+        className: cn2("flex shrink-0 items-center gap-1", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx2(
+            IconButton2,
+            {
+              variant: "ghost",
+              size: "icon-sm",
+              label: t("viewer.pager.previous"),
+              icon: /* @__PURE__ */ jsx2(ChevronLeftIcon, { "aria-hidden": "true" }),
+              disabled: pageNumber <= 1,
+              onClick: actions.previousPage
+            }
+          ),
+          /* @__PURE__ */ jsx2(
+            Input,
+            {
+              type: "text",
+              inputMode: "numeric",
+              autoComplete: "off",
+              spellCheck: false,
+              "aria-label": t("viewer.pager.pageNumber"),
+              value: draft ?? String(pageNumber),
+              onChange: (event) => setDraft(event.target.value),
+              onBlur: commit,
+              onKeyDown: (event) => {
+                if (event.key === "Enter") {
+                  event.preventDefault();
+                  commit();
+                } else if (event.key === "Escape") {
+                  setDraft(null);
+                }
+              },
+              className: "h-7 w-12 px-1 text-center tabular-nums"
+            }
+          ),
+          /* @__PURE__ */ jsx2("span", { className: "text-meta text-muted-foreground whitespace-nowrap tabular-nums", children: t("viewer.pager.of", { total: formatNumber(pageCount) }) }),
+          /* @__PURE__ */ jsx2(
+            IconButton2,
+            {
+              variant: "ghost",
+              size: "icon-sm",
+              label: t("viewer.pager.next"),
+              icon: /* @__PURE__ */ jsx2(ChevronRightIcon, { "aria-hidden": "true" }),
+              disabled: pageNumber >= pageCount,
+              onClick: actions.nextPage
+            }
+          ),
+          /* @__PURE__ */ jsx2("span", { role: "status", "aria-live": "polite", className: "sr-only", children: t("viewer.pager.status", {
+            page: formatNumber(pageNumber),
+            total: formatNumber(pageCount)
+          }) })
+        ]
+      }
+    );
+  }
+);
+
+// src/file-viewer/file-viewer-zoom.tsx
+import {
+  cn as cn3,
+  IconButton as IconButton3,
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectSeparator,
+  SelectTrigger,
+  SelectValue,
+  useLocale as useLocale3
+} from "@elabs-ai/components-ui";
+import { RotateCwIcon, ZoomInIcon, ZoomOutIcon } from "lucide-react";
+import { forwardRef as forwardRef3 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var FileViewerZoom = forwardRef3(
+  function FileViewerZoom2({ className, ...props }, ref) {
+    const { state, actions } = useFileViewer();
+    const { t, formatNumber } = useLocale3();
+    if (!state.capabilities.zoom) return null;
+    const { zoom, effectiveZoom } = state;
+    const percent = (scale) => formatNumber(scale, { style: "percent", maximumFractionDigits: 0 });
+    return /* @__PURE__ */ jsxs3(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-zoom",
+        role: "group",
+        "aria-label": t("viewer.zoom.controls"),
+        className: cn3("flex shrink-0 items-center gap-1", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx3(
+            IconButton3,
+            {
+              variant: "ghost",
+              size: "icon-sm",
+              label: t("viewer.zoom.out"),
+              icon: /* @__PURE__ */ jsx3(ZoomOutIcon, { "aria-hidden": "true" }),
+              disabled: !canStepZoom(effectiveZoom, -1),
+              onClick: actions.zoomOut
+            }
+          ),
+          /* @__PURE__ */ jsxs3(
+            Select,
+            {
+              value: zoomToValue(zoom),
+              onValueChange: (value) => actions.setZoom(valueToZoom(value)),
+              children: [
+                /* @__PURE__ */ jsx3(
+                  SelectTrigger,
+                  {
+                    size: "sm",
+                    "aria-label": t("viewer.zoom.level"),
+                    className: "h-7 w-24 gap-1 px-2",
+                    children: /* @__PURE__ */ jsx3(SelectValue, { children: isZoomFit(zoom) ? t(zoom === "fit-width" ? "viewer.zoom.fitWidth" : "viewer.zoom.fitPage") : percent(zoom) })
+                  }
+                ),
+                /* @__PURE__ */ jsxs3(SelectContent, { children: [
+                  /* @__PURE__ */ jsx3(SelectItem, { value: "fit-width", children: t("viewer.zoom.fitWidth") }),
+                  /* @__PURE__ */ jsx3(SelectItem, { value: "fit-page", children: t("viewer.zoom.fitPage") }),
+                  /* @__PURE__ */ jsx3(SelectSeparator, {}),
+                  VIEWER_ZOOM_STEPS.map((step) => /* @__PURE__ */ jsx3(SelectItem, { value: String(step), children: percent(step) }, step))
+                ] })
+              ]
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            IconButton3,
+            {
+              variant: "ghost",
+              size: "icon-sm",
+              label: t("viewer.zoom.in"),
+              icon: /* @__PURE__ */ jsx3(ZoomInIcon, { "aria-hidden": "true" }),
+              disabled: !canStepZoom(effectiveZoom, 1),
+              onClick: actions.zoomIn
+            }
+          ),
+          /* @__PURE__ */ jsx3("span", { role: "status", "aria-live": "polite", className: "sr-only", children: t("viewer.zoom.status", { level: percent(effectiveZoom) }) })
+        ]
+      }
+    );
+  }
+);
+function zoomToValue(zoom) {
+  return isZoomFit(zoom) ? zoom : String(zoom);
+}
+function valueToZoom(value) {
+  if (value === "fit-width" || value === "fit-page") return value;
+  const parsed = Number.parseFloat(value);
+  return Number.isNaN(parsed) ? 1 : parsed;
+}
+var FileViewerRotate = forwardRef3(
+  function FileViewerRotate2({ className, ...props }, ref) {
+    const { state, actions } = useFileViewer();
+    const { t } = useLocale3();
+    if (!state.capabilities.rotate) return null;
+    return /* @__PURE__ */ jsx3(
+      IconButton3,
+      {
+        ref,
+        "data-slot": "file-viewer-rotate",
+        variant: "ghost",
+        size: "icon-sm",
+        label: t("viewer.rotate"),
+        icon: /* @__PURE__ */ jsx3(RotateCwIcon, { "aria-hidden": "true" }),
+        className: cn3("shrink-0", className),
+        onClick: () => actions.rotate(1),
+        ...props
+      }
+    );
+  }
+);
+
+// src/file-viewer/file-viewer.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs4 } 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] = useState2(0);
+  const [state, setState] = useState2({ status: "empty", capabilities: {} });
+  const resolved = useMemo(() => source ? normalizeFileSource(source) : void 0, [source]);
+  useEffect2(() => {
+    if (!resolved) {
+      setState({ status: "empty", capabilities: {} });
+      return;
+    }
+    const controller = new AbortController();
+    let instance;
+    let cancelled = false;
+    const kind = resolveFileKind2(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] = useState2(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] = useState2(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] = useState2(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] = useState2(defaultZoom);
+  const zoom = zoomControlled ? zoomProp : ownZoom;
+  const setZoom = useCallback(
+    (next) => {
+      if (!zoomControlled) setOwnZoom(next);
+      onZoomChange?.(next);
+    },
+    [zoomControlled, onZoomChange]
+  );
+  const [reportedZoom, setReportedZoom] = useState2(DEFAULT_ZOOM);
+  const effectiveZoom = typeof zoom === "number" ? zoom : reportedZoom;
+  const rotationControlled = rotationProp !== void 0;
+  const [ownRotation, setOwnRotation] = useState2(defaultRotation);
+  const rotation = rotationControlled ? rotationProp : ownRotation;
+  const setRotation = useCallback(
+    (next) => {
+      if (!rotationControlled) setOwnRotation(next);
+      onRotationChange?.(next);
+    },
+    [rotationControlled, onRotationChange]
+  );
+  const previousSource = useRef2(resolved);
+  useEffect2(() => {
+    if (previousSource.current === resolved) return;
+    previousSource.current = resolved;
+    setOwnPage(1);
+    setOwnRotation(0);
+  }, [resolved]);
+  const [find, setFind] = useState2({
+    open: false,
+    query: "",
+    caseSensitive: false,
+    activeIndex: 0
+  });
+  const [findParts, setFindParts] = useState2(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__ */ jsx4(FileViewerContext, { value, children });
+}
+var FileViewerFrame = forwardRef4(
+  function FileViewerFrame2({ className, children, onKeyDown, ...props }, ref) {
+    const { state, actions, meta } = useFileViewer();
+    const { t } = useLocale4();
+    const frame = useRef2(null);
+    const wasOpen = useRef2(false);
+    const findOpen = state.find.open && meta.canFind;
+    useEffect2(() => {
+      if (wasOpen.current && !findOpen) {
+        frame.current?.querySelector('[data-slot="file-viewer-content"]')?.focus({ preventScroll: true });
+      }
+      wasOpen.current = findOpen;
+    }, [findOpen]);
+    return /* @__PURE__ */ jsx4(
+      "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: cn4(
+          "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 = forwardRef4(
+  function FileViewerToolbar2({ className, actions, children, ...props }, ref) {
+    const { state } = useFileViewer();
+    const { t } = useLocale4();
+    const source = state.source;
+    const Glyph = fileIconFor(source?.name ?? "", source?.mediaType);
+    if (!source) return null;
+    const download = () => {
+      void source.bytes().then((bytes) => {
+        downloadBlob(new Blob([bytes], { type: source.mediaType }), source.name);
+      });
+    };
+    return /* @__PURE__ */ jsxs4(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-toolbar",
+        className: cn4(
+          // 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__ */ jsx4(Glyph, { "aria-hidden": "true", className: "text-muted-foreground size-4 shrink-0" }),
+          /* @__PURE__ */ jsx4(Text, { className: "min-w-0 flex-1 truncate", title: source.name, children: source.name }),
+          children,
+          actions,
+          /* @__PURE__ */ jsx4(Separator2, { orientation: "vertical", className: "h-4" }),
+          /* @__PURE__ */ jsx4(
+            IconButton4,
+            {
+              variant: "ghost",
+              label: t("viewer.download", { name: source.name }),
+              icon: /* @__PURE__ */ jsx4(DownloadIcon, { "aria-hidden": "true" }),
+              onClick: download
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+var FileViewerHighlightStatus = forwardRef4(
+  function FileViewerHighlightStatus2({ className, ...props }, ref) {
+    const { state, meta } = useFileViewer();
+    const { t } = useLocale4();
+    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__ */ jsxs4(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-highlight-status",
+        role: "status",
+        "aria-live": "polite",
+        className: cn4(
+          // 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__ */ jsx4(SearchXIcon, { "aria-hidden": "true", className: "size-4 shrink-0" }),
+          /* @__PURE__ */ jsx4("span", { className: "text-meta min-w-0 flex-1 truncate", children: message })
+        ]
+      }
+    );
+  }
+);
+var FileViewerSkeleton = forwardRef4(
+  function FileViewerSkeleton2({ className, ...props }, ref) {
+    const { state } = useFileViewer();
+    const { t } = useLocale4();
+    return /* @__PURE__ */ jsxs4(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-skeleton",
+        role: "status",
+        "aria-live": "polite",
+        className: cn4("flex h-full flex-col gap-3 p-4", className),
+        ...props,
+        children: [
+          /* @__PURE__ */ jsx4("span", { className: "sr-only", children: t("viewer.loading", { name: state.source?.name ?? "" }) }),
+          /* @__PURE__ */ jsx4(Skeleton, { "aria-hidden": "true", className: "h-4 w-2/5" }),
+          /* @__PURE__ */ jsx4(Skeleton, { "aria-hidden": "true", className: "h-4 w-4/5" }),
+          /* @__PURE__ */ jsx4(Skeleton, { "aria-hidden": "true", className: "h-4 w-3/5" }),
+          /* @__PURE__ */ jsx4(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 = forwardRef4(
+  function FileViewerError2({ className, ...props }, ref) {
+    const { state } = useFileViewer();
+    const { t } = useLocale4();
+    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__ */ jsx4(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-error",
+        className: cn4("flex min-h-full flex-col justify-center p-4", className),
+        ...isGap ? { role: "status", "aria-live": "polite" } : {},
+        ...props,
+        children: /* @__PURE__ */ jsx4(
+          StatePanel,
+          {
+            kind: isGap ? "empty" : "error",
+            className: isGap ? "border-solid" : void 0,
+            icon: isGap ? /* @__PURE__ */ jsx4(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__ */ jsx4(RetryButton, {}) : void 0
+          }
+        )
+      }
+    );
+  }
+);
+function RetryButton() {
+  const { actions } = useFileViewer();
+  const { t } = useLocale4();
+  return /* @__PURE__ */ jsx4(Button, { variant: "outline", size: "sm", onClick: actions.reload, children: t("viewer.retry") });
+}
+var FileViewerEmpty = forwardRef4(
+  function FileViewerEmpty2({ className, ...props }, ref) {
+    const { t } = useLocale4();
+    return /* @__PURE__ */ jsx4(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-empty",
+        className: cn4("flex min-h-full flex-col justify-center p-4", className),
+        ...props,
+        children: /* @__PURE__ */ jsx4(StatePanel, { kind: "empty", title: t("viewer.empty"), description: t("viewer.emptyBody") })
+      }
+    );
+  }
+);
+var FileViewerContent = forwardRef4(
+  function FileViewerContent2({ className, ...props }, ref) {
+    const { state, actions, meta } = useFileViewer();
+    const { t } = useLocale4();
+    return /* @__PURE__ */ jsxs4(
+      "div",
+      {
+        ref,
+        "data-slot": "file-viewer-content",
+        role: "region",
+        "aria-label": t("viewer.content"),
+        tabIndex: 0,
+        className: cn4(
+          "focus-visible:ring-ring min-h-0 flex-1 overflow-auto p-4 focus-visible:outline-none focus-visible:ring-2",
+          className
+        ),
+        ...props,
+        children: [
+          state.status === "empty" && /* @__PURE__ */ jsx4(FileViewerEmpty, {}),
+          state.status === "loading" && /* @__PURE__ */ jsx4(FileViewerSkeleton, {}),
+          state.status === "error" && /* @__PURE__ */ jsx4(FileViewerError, {}),
+          state.status === "ready" && state.adapter && state.document && state.source && /* @__PURE__ */ jsx4(
+            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 = forwardRef4(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__ */ jsx4(
+    FileViewerProvider,
+    {
+      source,
+      registry,
+      loading,
+      baseHeadingLevel,
+      highlights,
+      defaultHighlights,
+      onHighlightsChange,
+      activeHighlightId,
+      defaultActiveHighlightId,
+      onActiveHighlightChange,
+      pageNumber,
+      defaultPageNumber,
+      onPageNumberChange,
+      zoom,
+      defaultZoom,
+      onZoomChange,
+      rotation,
+      defaultRotation,
+      onRotationChange,
+      children: /* @__PURE__ */ jsx4(FileViewerFrame, { ref, ...props, children: children ?? /* @__PURE__ */ jsxs4(Fragment, { children: [
+        /* @__PURE__ */ jsxs4(FileViewerToolbar, { children: [
+          /* @__PURE__ */ jsx4(FileViewerPager, {}),
+          /* @__PURE__ */ jsx4(FileViewerZoom, {}),
+          /* @__PURE__ */ jsx4(FileViewerRotate, {})
+        ] }),
+        /* @__PURE__ */ jsx4(FileViewerFind, {}),
+        /* @__PURE__ */ jsx4(FileViewerHighlightStatus, {}),
+        /* @__PURE__ */ jsx4(FileViewerContent, {})
+      ] }) })
+    }
+  );
+});
+export {
+  ACTIVE_HIGHLIGHT_SELECTOR,
+  DEFAULT_ZOOM,
+  FIND_MATCH_LIMIT,
+  FileViewer,
+  FileViewerContent,
+  FileViewerEmpty,
+  FileViewerError,
+  FileViewerFind,
+  FileViewerFrame,
+  FileViewerHighlightStatus,
+  FileViewerPager,
+  FileViewerProvider,
+  FileViewerRotate,
+  FileViewerSkeleton,
+  FileViewerToolbar,
+  FileViewerZoom,
+  PROTOCOL_VERSION,
+  VIEWER_ZOOM_STEPS,
+  ViewerError,
+  canStepZoom,
+  chunkOffset,
+  codeManifest,
+  configurePdfEngine,
+  createDefaultRegistry,
+  createRegistry,
+  createTextIndexBuilder,
+  csvManifest,
+  docxManifest,
+  findMatchId,
+  getPdfEngineConfig,
+  imageManifest,
+  isAbort,
+  isFindMatchId,
+  isFindShortcut,
+  isModuleNotFound,
+  isViewerError,
+  isZoomFit,
+  jsonManifest,
+  localizeRanges,
+  locateQuote,
+  markdownManifest,
+  mediaManifest,
+  parserMissingError,
+  pdfManifest,
+  pptxManifest,
+  resolveHighlights,
+  scoreManifest,
+  spanAt,
+  spansForRange,
+  stepZoom,
+  textManifest,
+  toMarkRanges,
+  toViewerError,
+  useFileViewer,
+  useScrollActiveHighlightIntoView,
+  xlsxManifest
+};
+//# sourceMappingURL=index.js.map