@anaralabs/lector 3.4.0 → 3.5.1

package/README.md

@@ -1,5 +1,4 @@
 <p align="center">
-  <!-- <h1 align="center"><img src="https://www.anara.ai/icons/logo.png" width="196" /></h1> -->
   <p align="center">
     <i>Simple primitives to compose powerful PDF viewing experiences.<br>powered by <code><a href="https://mozilla.github.io/pdf.js/">PDF.js</a></code> and <code><a href="https://reactjs.org/">React</a></code></i>
   </p>

package/dist/_tsup-dts-rollup.d.ts

@@ -16,8 +16,42 @@ import { ReactNode } from 'react';
 import { RefAttributes } from 'react';
 import { StoreApi } from 'zustand';
 import type { TypedArray } from 'pdfjs-dist/types/src/display/api';
+import { UseBoundStore } from 'zustand';
+import { useFloating } from '@floating-ui/react';
+import { useInteractions } from '@floating-ui/react';
 import { Virtualizer } from '@tanstack/react-virtual';
 
+declare interface Annotation {
+    id: string;
+    pageNumber: number;
+    highlights: Array<{
+        height: number;
+        left: number;
+        top: number;
+        width: number;
+        pageNumber: number;
+    }>;
+    comment?: string;
+    color?: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+export { Annotation }
+export { Annotation as Annotation_alias_1 }
+
+export declare const AnnotationHighlightLayer: ({ className, style, renderTooltipContent, focusedAnnotationId, onAnnotationClick, }: AnnotationHighlightLayerProps) => JSX.Element;
+
+declare interface AnnotationHighlightLayerProps {
+    className?: string;
+    style?: React.CSSProperties;
+    renderTooltipContent: (props: {
+        annotation: Annotation;
+        onClose: () => void;
+    }) => React.ReactNode;
+    focusedAnnotationId?: string;
+    onAnnotationClick?: (annotation: Annotation) => void;
+}
+
 /**
  * AnnotationLayer renders PDF annotations like links, highlights, and form fields.
  *
@@ -47,6 +81,24 @@ declare interface AnnotationLayerParams {
     jumpOptions?: Parameters<ReturnType<typeof usePdfJump>['jumpToPage']>[1];
 }
 
+declare interface AnnotationState {
+    annotations: Annotation[];
+    addAnnotation: (annotation: Omit<Annotation, "id" | "createdAt" | "updatedAt">) => void;
+    updateAnnotation: (id: string, updates: Partial<Annotation>) => void;
+    deleteAnnotation: (id: string) => void;
+    setAnnotations: (annotations: Annotation[]) => void;
+}
+
+export declare const AnnotationTooltip: ({ annotation, children, tooltipContent, onOpenChange, isOpen: controlledIsOpen, }: AnnotationTooltipProps) => JSX.Element;
+
+declare interface AnnotationTooltipProps {
+    annotation: Annotation;
+    children: React.ReactNode;
+    tooltipContent: React.ReactNode;
+    onOpenChange?: (open: boolean) => void;
+    isOpen?: boolean;
+}
+
 /**
  * Calculates the highlight rectangles for a given text match.
  *
@@ -276,8 +328,6 @@ export declare interface SearchResults {
     hasMoreResults: boolean;
 }
 
-declare type Selection_2 = Omit<CollapsibleSelection, "isCollapsed">;
-
 export declare const SelectionTooltip: ({ children }: SelectionTooltipProps) => JSX.Element;
 
 declare interface SelectionTooltipProps {
@@ -310,6 +360,26 @@ export declare const Thumbnails: ({ children, ...props }: HTMLProps<HTMLDivEleme
 
 export declare const TotalPages: ({ ...props }: HTMLProps<HTMLDivElement>) => JSX.Element;
 
+declare const useAnnotations: UseBoundStore<StoreApi<AnnotationState>>;
+export { useAnnotations }
+export { useAnnotations as useAnnotations_alias_1 }
+
+export declare const useAnnotationTooltip: ({ annotation, onOpenChange, }: UseAnnotationTooltipProps) => UseAnnotationTooltipReturn;
+
+declare interface UseAnnotationTooltipProps {
+    annotation: Annotation;
+    onOpenChange?: (open: boolean) => void;
+}
+
+declare interface UseAnnotationTooltipReturn {
+    isOpen: boolean;
+    setIsOpen: (open: boolean) => void;
+    refs: ReturnType<typeof useFloating>["refs"];
+    floatingStyles: ReturnType<typeof useFloating>["floatingStyles"];
+    getFloatingProps: ReturnType<typeof useInteractions>["getFloatingProps"];
+    getReferenceProps: ReturnType<typeof useInteractions>["getReferenceProps"];
+}
+
 declare const usePdf: <T>(selector: (state: PDFState) => T) => T;
 export { usePdf }
 export { usePdf as usePdf_alias_1 }
@@ -355,6 +425,8 @@ declare const usePDFOutline: () => {
     items: Array<any>;
 }[] | undefined;
 
+export declare const usePDFPageNumber: () => number;
+
 export declare const useSearch: () => {
     textContent: {
         pageNumber: number;
@@ -366,8 +438,12 @@ export declare const useSearch: () => {
 };
 
 export declare const useSelectionDimensions: () => {
-    getDimension: () => CollapsibleSelection | undefined;
-    getSelection: () => Selection_2;
+    getDimension: () => {
+        highlights: HighlightRect[];
+        text: string;
+        isCollapsed: boolean;
+    } | undefined;
+    getSelection: () => CollapsibleSelection;
 };
 
 export declare const ZoomIn: ({ ...props }: HTMLProps<HTMLButtonElement>) => JSX.Element;

package/dist/index.d.ts

@@ -1,3 +1,5 @@
+export { AnnotationTooltip } from './_tsup-dts-rollup.js';
+export { AnnotationHighlightLayer } from './_tsup-dts-rollup.js';
 export { AnnotationLayer } from './_tsup-dts-rollup.js';
 export { CanvasLayer } from './_tsup-dts-rollup.js';
 export { ColoredHighlightLayer } from './_tsup-dts-rollup.js';
@@ -26,7 +28,10 @@ export { SearchResult } from './_tsup-dts-rollup.js';
 export { SearchResults } from './_tsup-dts-rollup.js';
 export { useSearch } from './_tsup-dts-rollup.js';
 export { calculateHighlightRects } from './_tsup-dts-rollup.js';
+export { Annotation } from './_tsup-dts-rollup.js';
+export { useAnnotations } from './_tsup-dts-rollup.js';
 export { LinkService } from './_tsup-dts-rollup.js';
+export { usePDFPageNumber } from './_tsup-dts-rollup.js';
 export { useSelectionDimensions } from './_tsup-dts-rollup.js';
 export { ColoredHighlight } from './_tsup-dts-rollup.js';
 export { HighlightRect } from './_tsup-dts-rollup.js';

package/dist/index.js

@@ -1,30 +1,16 @@
 'use client';
 
-import { AnnotationLayer, TextLayer, getDocument } from 'pdfjs-dist';
-import React, { createContext, forwardRef, useContext, useState, useRef, useCallback, useEffect, cloneElement, createRef, useLayoutEffect } from 'react';
+import React, { createContext, forwardRef, useCallback, useContext, useState, useRef, useEffect, cloneElement, createRef, useLayoutEffect } from 'react';
+import { useFloating, autoUpdate, offset, shift, useDismiss, useInteractions, flip } from '@floating-ui/react';
 import { useVirtualizer, elementScroll, debounce } from '@tanstack/react-virtual';
-import { useStore, createStore } from 'zustand';
+import { create, useStore, createStore } from 'zustand';
 import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
-import { useDebounce } from 'use-debounce';
 import { v4 } from 'uuid';
-import { useFloating, autoUpdate, offset, shift, useDismiss, useInteractions } from '@floating-ui/react';
+import { AnnotationLayer, TextLayer, getDocument } from 'pdfjs-dist';
+import { useDebounce } from 'use-debounce';
 import { Slot } from '@radix-ui/react-slot';
 
-// ../../node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
-function r(e) {
-  var t, f, n = "";
-  if ("string" == typeof e || "number" == typeof e) n += e;
-  else if ("object" == typeof e) if (Array.isArray(e)) {
-    var o = e.length;
-    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
-  } else for (f in e) e[f] && (n && (n += " "), n += f);
-  return n;
-}
-function clsx() {
-  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
-  return n;
-}
-var clsx_default = clsx;
+// src/components/annotation-tooltip.tsx
 
 // src/lib/clamp.ts
 var clamp = (value, min, max) => {
@@ -146,6 +132,258 @@ var PDFStore = createZustandContext(
 );
 var usePdf = (selector) => useStore(PDFStore.useContext(), selector);
 
+// src/hooks/useAnnotationTooltip.ts
+var defaultRect = {
+  width: 0,
+  height: 0,
+  x: 0,
+  y: 0,
+  top: 0,
+  right: 0,
+  bottom: 0,
+  left: 0
+};
+var useAnnotationTooltip = ({
+  annotation,
+  onOpenChange
+}) => {
+  const isNewAnnotation = Date.now() - new Date(annotation.createdAt).getTime() < 1e3;
+  const [isOpen, setIsOpen] = useState(isNewAnnotation);
+  const viewportRef = usePdf((state) => state.viewportRef);
+  const {
+    refs,
+    floatingStyles,
+    context
+  } = useFloating({
+    placement: "top",
+    open: isOpen,
+    onOpenChange: (open) => {
+      setIsOpen(open);
+      onOpenChange?.(open);
+    },
+    whileElementsMounted: autoUpdate,
+    middleware: [
+      offset(10),
+      flip({
+        crossAxis: false
+      }),
+      shift({ padding: 8 })
+    ]
+  });
+  const dismiss = useDismiss(context);
+  const { getReferenceProps, getFloatingProps } = useInteractions([dismiss]);
+  const updateTooltipPosition = useCallback(() => {
+    if (!annotation.highlights.length) return;
+    const lastHighlight = annotation.highlights[annotation.highlights.length - 1];
+    refs.setReference({
+      getBoundingClientRect: () => {
+        const viewportElement = viewportRef.current;
+        if (!viewportElement || !lastHighlight) return defaultRect;
+        const pageElement = viewportElement.querySelector(`[data-page-number="${annotation.pageNumber}"]`);
+        if (!pageElement) return defaultRect;
+        const pageRect = pageElement.getBoundingClientRect();
+        const left = pageRect.left + lastHighlight.left;
+        const top = pageRect.top + lastHighlight.top;
+        const width = lastHighlight.width;
+        const height = lastHighlight.height;
+        return {
+          width,
+          height,
+          x: left,
+          y: top,
+          top,
+          right: left + width,
+          bottom: top + height,
+          left
+        };
+      }
+    });
+  }, [annotation.highlights, annotation.pageNumber, refs, viewportRef]);
+  useEffect(() => {
+    const viewport = viewportRef.current;
+    updateTooltipPosition();
+    const handleScroll = () => {
+      requestAnimationFrame(updateTooltipPosition);
+    };
+    const handleResize = () => {
+      requestAnimationFrame(updateTooltipPosition);
+    };
+    if (viewport) {
+      viewport.addEventListener("scroll", handleScroll, {
+        passive: true
+      });
+    }
+    window.addEventListener("resize", handleResize, { passive: true });
+    return () => {
+      if (viewport) {
+        viewport.removeEventListener("scroll", handleScroll);
+      }
+      window.removeEventListener("resize", handleResize);
+    };
+  }, [updateTooltipPosition, viewportRef]);
+  return {
+    isOpen,
+    setIsOpen,
+    refs,
+    floatingStyles,
+    getFloatingProps,
+    getReferenceProps
+  };
+};
+var AnnotationTooltip = ({
+  annotation,
+  children,
+  tooltipContent,
+  onOpenChange,
+  isOpen: controlledIsOpen
+}) => {
+  const {
+    isOpen: uncontrolledIsOpen,
+    setIsOpen,
+    refs,
+    floatingStyles,
+    getFloatingProps,
+    getReferenceProps
+  } = useAnnotationTooltip({
+    annotation,
+    onOpenChange
+  });
+  const isOpen = controlledIsOpen ?? uncontrolledIsOpen;
+  const handleClick = useCallback(() => {
+    if (controlledIsOpen === void 0) {
+      setIsOpen(!isOpen);
+    }
+  }, [controlledIsOpen, isOpen, setIsOpen]);
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: refs.setReference,
+        onClick: handleClick,
+        ...getReferenceProps(),
+        children
+      }
+    ),
+    isOpen && /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: refs.setFloating,
+        className: "bg-white shadow-lg rounded-lg p-3 z-50 min-w-[200px]",
+        style: {
+          ...floatingStyles,
+          position: "fixed",
+          zIndex: 9999
+        },
+        ...getFloatingProps(),
+        children: tooltipContent
+      }
+    )
+  ] });
+};
+var useAnnotations = create((set) => ({
+  annotations: [],
+  addAnnotation: (annotation) => set((state) => ({
+    annotations: [
+      ...state.annotations,
+      {
+        ...annotation,
+        id: v4(),
+        createdAt: /* @__PURE__ */ new Date(),
+        updatedAt: /* @__PURE__ */ new Date()
+      }
+    ]
+  })),
+  updateAnnotation: (id, updates) => set((state) => ({
+    annotations: state.annotations.map(
+      (annotation) => annotation.id === id ? {
+        ...annotation,
+        ...updates,
+        updatedAt: /* @__PURE__ */ new Date()
+      } : annotation
+    )
+  })),
+  deleteAnnotation: (id) => set((state) => ({
+    annotations: state.annotations.filter((annotation) => annotation.id !== id)
+  })),
+  setAnnotations: (annotations) => set({ annotations })
+}));
+var PDFPageNumberContext = createContext(0);
+var usePDFPageNumber = () => {
+  return useContext(PDFPageNumberContext);
+};
+var AnnotationHighlightLayer = ({
+  className,
+  style,
+  renderTooltipContent,
+  focusedAnnotationId,
+  onAnnotationClick
+}) => {
+  const { annotations } = useAnnotations();
+  const pageNumber = usePDFPageNumber();
+  const pageAnnotations = annotations.filter(
+    (annotation) => annotation.pageNumber === pageNumber
+  );
+  return /* @__PURE__ */ jsx("div", { className, style, children: pageAnnotations.map((annotation) => /* @__PURE__ */ jsx(
+    AnnotationTooltip,
+    {
+      annotation,
+      isOpen: focusedAnnotationId === annotation.id,
+      onOpenChange: (open) => {
+        if (open && onAnnotationClick) {
+          onAnnotationClick(annotation);
+        }
+      },
+      tooltipContent: renderTooltipContent({
+        annotation,
+        onClose: () => {
+        }
+      }),
+      children: /* @__PURE__ */ jsx(
+        "div",
+        {
+          style: { cursor: "pointer" },
+          onClick: () => onAnnotationClick?.(annotation),
+          children: annotation.highlights.map((highlight, index) => /* @__PURE__ */ jsx(
+            "div",
+            {
+              style: {
+                position: "absolute",
+                top: highlight.top,
+                left: highlight.left,
+                width: highlight.width,
+                height: highlight.height,
+                backgroundColor: annotation.color || "rgba(255, 255, 0, 0.3)",
+                mixBlendMode: "multiply",
+                transition: "all 0.2s ease",
+                cursor: "pointer"
+              },
+              "data-highlight-id": annotation.id
+            },
+            index
+          ))
+        }
+      )
+    },
+    annotation.id
+  )) });
+};
+
+// ../../node_modules/.pnpm/clsx@2.1.1/node_modules/clsx/dist/clsx.mjs
+function r(e) {
+  var t, f, n = "";
+  if ("string" == typeof e || "number" == typeof e) n += e;
+  else if ("object" == typeof e) if (Array.isArray(e)) {
+    var o = e.length;
+    for (t = 0; t < o; t++) e[t] && (f = r(e[t])) && (n && (n += " "), n += f);
+  } else for (f in e) e[f] && (n && (n += " "), n += f);
+  return n;
+}
+function clsx() {
+  for (var e, t, f = 0, n = "", o = arguments.length; f < o; f++) (e = arguments[f]) && (t = r(e)) && (n && (n += " "), n += t);
+  return n;
+}
+var clsx_default = clsx;
+
 // src/lib/cancellable.ts
 var cancellable = (promise) => {
   let isCancelled = false;
@@ -184,9 +422,9 @@ var usePdfJump = () => {
     const finalOptions = { ...defaultOptions, ...options };
     virtualizer.scrollToIndex(pageIndex - 1, finalOptions);
   };
-  const jumpToOffset = (offset2) => {
+  const jumpToOffset = (offset3) => {
     if (!virtualizer) return;
-    virtualizer.scrollToOffset(offset2, {
+    virtualizer.scrollToOffset(offset3, {
       align: "start",
       behavior: "smooth"
     });
@@ -387,10 +625,6 @@ var PDFLinkServiceContext = createContext(defaultLinkService);
 var usePDFLinkService = () => {
   return useContext(PDFLinkServiceContext);
 };
-var PDFPageNumberContext = createContext(0);
-var usePDFPageNumber = () => {
-  return useContext(PDFPageNumberContext);
-};
 var useVisibility = ({
   elementRef
 }) => {
@@ -671,13 +905,13 @@ var CanvasLayer = ({
 };
 
 // src/hooks/useSelectionDimensions.tsx
-var MERGE_THRESHOLD = 20;
-var shouldMergeRectangles = (rect1, rect2) => {
+var MERGE_THRESHOLD = 5;
+var shouldMergeRects = (rect1, rect2) => {
   const verticalOverlap = !(rect1.top > rect2.top + rect2.height || rect2.top > rect1.top + rect1.height);
   const horizontallyClose = Math.abs(rect1.left + rect1.width - rect2.left) < MERGE_THRESHOLD || Math.abs(rect2.left + rect2.width - rect1.left) < MERGE_THRESHOLD || rect1.left < rect2.left + rect2.width && rect2.left < rect1.left + rect1.width;
   return verticalOverlap && horizontallyClose;
 };
-var mergeRectangles = (rect1, rect2) => {
+var mergeRects = (rect1, rect2) => {
   return {
     left: Math.min(rect1.left, rect2.left),
     top: Math.min(rect1.top, rect2.top),
@@ -688,38 +922,28 @@ var mergeRectangles = (rect1, rect2) => {
 };
 var consolidateRects = (rects) => {
   if (rects.length <= 1) return rects;
-  const sortedRectangles = rects.toSorted((a, b) => a.top - b.top);
-  let withinThresholdMergedRectangles = sortedRectangles[0];
-  const allMergedRectangles = [];
-  const blowUpMergedRectangles = (rect) => {
-    return {
-      ...rect,
-      left: rect.left - 2,
-      top: rect.top - 2,
-      width: rect.width + 4,
-      height: rect.height + 2
-    };
-  };
-  for (const [index, currentRectangle] of sortedRectangles.entries()) {
-    withinThresholdMergedRectangles = mergeRectangles(
-      withinThresholdMergedRectangles,
-      currentRectangle
-    );
-    const nextRectangle = sortedRectangles[index + 1];
-    if (!nextRectangle) {
-      allMergedRectangles.push(
-        blowUpMergedRectangles(withinThresholdMergedRectangles)
-      );
-      break;
-    }
-    if (!shouldMergeRectangles(withinThresholdMergedRectangles, nextRectangle)) {
-      allMergedRectangles.push(
-        blowUpMergedRectangles(withinThresholdMergedRectangles)
-      );
-      withinThresholdMergedRectangles = nextRectangle;
+  const sortedRects = [...rects].sort((a, b) => a.top - b.top);
+  let hasChanges;
+  do {
+    hasChanges = false;
+    let currentRect = sortedRects[0];
+    const tempResult = [];
+    for (let i = 1; i < sortedRects.length; i++) {
+      const sorted = sortedRects[i];
+      if (!currentRect || !sorted) continue;
+      if (shouldMergeRects(currentRect, sorted)) {
+        currentRect = mergeRects(currentRect, sorted);
+        hasChanges = true;
+      } else {
+        tempResult.push(currentRect);
+        currentRect = sorted;
+      }
     }
-  }
-  return allMergedRectangles;
+    if (currentRect) tempResult.push(currentRect);
+    sortedRects.length = 0;
+    sortedRects.push(...tempResult);
+  } while (hasChanges);
+  return sortedRects;
 };
 var useSelectionDimensions = () => {
   const store = PDFStore.useContext();
@@ -1048,13 +1272,15 @@ var ColoredHighlightLayer = ({
   onHighlight
 }) => {
   const pageNumber = usePDFPageNumber();
-  const { getSelection } = useSelectionDimensions();
+  const { getDimension } = useSelectionDimensions();
   const highlights = usePdf(
     (state) => state.coloredHighlights
   );
   const addColoredHighlight = usePdf((state) => state.addColoredHighlight);
   const handleHighlighting = useCallback((color) => {
-    const { highlights: highlights2, text } = getSelection();
+    const dimension = getDimension();
+    if (!dimension) return;
+    const { highlights: highlights2, text } = dimension;
     if (highlights2[0]) {
       const highlight = {
         uuid: v4(),
@@ -1336,6 +1562,7 @@ var Page = ({
           style: {
             ...style,
             "--scale-factor": 1,
+            "--total-scale-factor": 1,
             position: "relative",
             width,
             height
@@ -1442,21 +1669,21 @@ var useObserveElement = () => {
     if (!targetWindow) {
       return;
     }
-    let offset2 = 0;
+    let offset3 = 0;
     const fallback = instance.options.useScrollendEvent && supportsScrollend ? () => void 0 : debounce(
       targetWindow,
       () => {
-        cb(offset2, false);
+        cb(offset3, false);
       },
       instance.options.isScrollingResetDelay
     );
     const createHandler = (isScrolling) => () => {
       const { horizontal, isRtl } = instance.options;
-      offset2 = horizontal ? element["scrollLeft"] * (isRtl && -1 || 1) : element["scrollTop"];
+      offset3 = horizontal ? element["scrollLeft"] * (isRtl && -1 || 1) : element["scrollTop"];
       const zoom = store.getState().zoom;
-      offset2 = offset2 / zoom;
+      offset3 = offset3 / zoom;
       fallback();
-      cb(offset2, isScrolling);
+      cb(offset3, isScrolling);
     };
     const handler = createHandler(true);
     const endHandler = createHandler(false);
@@ -1477,8 +1704,8 @@ var useScrollFn = () => {
   const scrollToFn = useCallback(
     (_offset, canSmooth, instance) => {
       const zoom = store.getState().zoom;
-      const offset2 = _offset * zoom;
-      elementScroll(offset2, canSmooth, instance);
+      const offset3 = _offset * zoom;
+      elementScroll(offset3, canSmooth, instance);
     },
     [store]
   );
@@ -2593,10 +2820,10 @@ var PinchEngine = class extends Engine {
   }
   computeMovement() {
     const {
-      offset: offset2,
+      offset: offset3,
       lastOffset
     } = this.state;
-    this.state.movement = [offset2[0] / lastOffset[0], offset2[1] - lastOffset[1]];
+    this.state.movement = [offset3[0] / lastOffset[0], offset3[1] - lastOffset[1]];
   }
   axisIntent() {
     const state = this.state;
@@ -4153,4 +4380,4 @@ function mergeAdjacentRects(rects) {
   return merged;
 }
 
-export { AnnotationLayer2 as AnnotationLayer, CanvasLayer, ColoredHighlightLayer, CurrentPage, CurrentZoom, CustomLayer, HighlightLayer, LinkService, NextPage, Outline, OutlineChildItems, OutlineItem, Page, Pages, PreviousPage, Root, Search, SelectionTooltip, TextLayer2 as TextLayer, Thumbnail, Thumbnails, TotalPages, ZoomIn, ZoomOut, calculateHighlightRects, usePdf, usePdfJump, useSearch, useSelectionDimensions };
+export { AnnotationHighlightLayer, AnnotationLayer2 as AnnotationLayer, AnnotationTooltip, CanvasLayer, ColoredHighlightLayer, CurrentPage, CurrentZoom, CustomLayer, HighlightLayer, LinkService, NextPage, Outline, OutlineChildItems, OutlineItem, Page, Pages, PreviousPage, Root, Search, SelectionTooltip, TextLayer2 as TextLayer, Thumbnail, Thumbnails, TotalPages, ZoomIn, ZoomOut, calculateHighlightRects, useAnnotations, usePDFPageNumber, usePdf, usePdfJump, useSearch, useSelectionDimensions };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@anaralabs/lector",
-  "version": "3.4.0",
+  "version": "3.5.1",
   "description": "Headless PDF viewer for React",
   "author": "andrewdr (https://github.com/andrewdoro)",
   "license": "MIT",