vue-pdfjs-headless 4.4.0 → 4.6.0

package/README.md

@@ -5,7 +5,7 @@
 [![NPM downloads][badge-npm-downloads]][url-npm]
 [![NPM Unpacked Size (with version)][badge-npm-unpacked-size]][url-npm]
 
-Headless Vue composables over pdfjs-dist that load a document, draw its pages and track the viewer's state, with no styling and no renderer of its own.
+This package provides headless Vue composables over pdfjs-dist. The composables load a document, draw its pages and track the viewer's state, with no styling and no renderer of their own.
 
 Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/openspec/specs/vue-pdfjs-headless).
 
@@ -19,10 +19,14 @@ Design notes live in [the specs](https://github.com/Esposter/Esposter/tree/main/
 
 ## <a name="getting-started">🚀 Getting Started</a>
 
+1. Install the package.
+
 ```bash
 pnpm i vue-pdfjs-headless
 ```
 
+2. Add this code to the `<script setup>` of a component.
+
 ```ts
 import * as pdfjs from "pdfjs-dist";
 import { shallowRef } from "vue";
@@ -42,23 +46,23 @@ const { pdfDocument } = usePdfDocument({
 usePdfPage({ canvas, pageNumber: 1, pdfDocument });
 ```
 
-Bind `canvas` to a `<canvas ref="canvas" />` in the component's template, and the page is drawn into it.
+3. Bind `canvas` to a `<canvas ref="canvas" />` in the template. The first page appears in the canvas.
 
 ## <a name="key-exports">🧩 Key Exports</a>
 
-| Export              | Kind       | Purpose                                                                                                       |
-| ------------------- | ---------- | ------------------------------------------------------------------------------------------------------------- |
-| `PdfRenderer`       | interface  | The renderer's API module, its data folder URLs and its worker, which the consumer supplies                   |
-| `PdfSource`         | type       | A document by its URL, its bytes, or a file the reader picked                                                 |
-| `PdfViewerState`    | interface  | The viewer's pages, zoom, rotation, search, download and print, as state and actions                          |
-| `readXfdf`          | function   | Reads the free-text annotations of an XFDF file, or an error naming what is wrong with it                     |
-| `usePdfAnnotations` | composable | The reader's comments and free-text annotations, exported to and imported from XFDF                           |
-| `usePdfDocument`    | composable | Loads a document from a source through the consumer's renderer, with its password prompt and failure as state |
-| `usePdfPage`        | composable | Draws one page of a loaded document into a canvas, at the canvas's width and the device's pixel ratio         |
-| `usePdfThumbnails`  | composable | One thumbnail per page, drawn only while its row is in view of the sidebar                                    |
-| `usePdfViewer`      | composable | Builds the renderer's viewer for a loaded document, with its pages, zoom and search as state                  |
-| `usePdfZoomGesture` | composable | Pinch and Ctrl-wheel zoom the viewer about the pointer, keeping the content under it in place                 |
-| `writeXfdf`         | function   | Writes free-text annotations as XFDF                                                                          |
+| Export              | Kind       | Purpose                                                                                                        |
+| ------------------- | ---------- | -------------------------------------------------------------------------------------------------------------- |
+| `PdfRenderer`       | interface  | The renderer: its API module, its data folder URLs and its worker. The consumer supplies it.                   |
+| `PdfSource`         | type       | A document, given by its URL, its bytes or a file that the reader picked                                       |
+| `PdfViewerState`    | interface  | The viewer's pages, zoom, rotation, search, download and print, as state and actions                           |
+| `readXfdf`          | function   | Reads the free-text annotations of an XFDF file, or returns an error that names what is wrong with it          |
+| `usePdfAnnotations` | composable | Lists the reader's comments once they are wanted, and imports and exports free texts as XFDF                   |
+| `usePdfDocument`    | composable | Loads a document from a source through the consumer's renderer. Its password prompt and its failure are state. |
+| `usePdfPage`        | composable | Draws one page of a loaded document into a canvas, at the canvas's width and the device's pixel ratio          |
+| `usePdfThumbnails`  | composable | One thumbnail per page. A thumbnail's page is loaded and drawn only while its row is in view of the sidebar.   |
+| `usePdfViewer`      | composable | Builds the renderer's viewer for a loaded document. Its pages, zoom and search are state.                      |
+| `usePdfZoomGesture` | composable | Zooms the viewer about the pointer on a pinch or a Ctrl-wheel. The content under the pointer stays in place.   |
+| `writeXfdf`         | function   | Writes free-text annotations as XFDF                                                                           |
 
 ## <a name="license">⚖️ License</a>
 

package/dist/index.d.ts

@@ -0,0 +1,211 @@
+import { Result } from "neverthrow";
+import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+import * as PdfJs from "pdfjs-dist";
+import { PDFDocumentLoadingTask, PDFDocumentProxy, PDFPageProxy, PageViewport } from "pdfjs-dist";
+import * as PdfJsViewer from "pdfjs-dist/web/pdf_viewer.mjs";
+import { PDFViewer } from "pdfjs-dist/web/pdf_viewer.mjs";
+export declare enum PdfEditorMode {
+  None = 0,
+  FreeText = 3,
+  Highlight = 9,
+  Stamp = 13,
+  Ink = 15
+}
+export interface PdfAnnotationChange {
+  kind: PdfEditorMode;
+  pageNumber: number;
+}
+export interface PdfComment {
+  contents: string;
+  pageNumber: number;
+}
+export interface PdfAnnotationsState {
+  comments: ShallowRef<PdfComment[] | undefined>;
+  exportXfdf: () => string;
+  importXfdf: (xfdf: string) => Result<void, string>;
+  setEditorMode: (mode: PdfEditorMode) => void;
+}
+export interface PdfMatchesCount {
+  current: number;
+  total: number;
+}
+export type PdfOutline = NonNullable<Awaited<ReturnType<PDFDocumentProxy["getOutline"]>>>;
+export interface PdfPageOverlay {
+  element: HTMLElement;
+  pageNumber: number;
+  viewport: PageViewport;
+}
+export interface PdfViewerState {
+  actualSize: () => void;
+  currentPageNumber: Ref<number>;
+  download: (filename: string, watermark?: string) => void;
+  drawStoredEditors: () => void;
+  editorMode: Ref<PdfEditorMode>;
+  findNext: () => void;
+  findPrevious: () => void;
+  fitPage: () => void;
+  fitWidth: () => void;
+  followBookmark: (item: PdfOutline[number]) => void;
+  goToPage: (pageNumber: number) => void;
+  isMatchCase: Ref<boolean>;
+  isNotFound: Ref<boolean>;
+  isWholeWord: Ref<boolean>;
+  isZoomInDisabled: ComputedRef<boolean>;
+  isZoomOutDisabled: ComputedRef<boolean>;
+  matchesCount: Ref<PdfMatchesCount>;
+  nextPage: () => void;
+  outline: ShallowRef<PdfOutline | undefined>;
+  overlays: ShallowRef<PdfPageOverlay[]>;
+  pagesCount: Ref<number>;
+  pagesRotation: Ref<number>;
+  previousPage: () => void;
+  print: () => void;
+  resetZoom: () => void;
+  rotate: (degrees: number) => void;
+  scale: Ref<number>;
+  searchQuery: Ref<string>;
+  zoomIn: () => void;
+  zoomOut: () => void;
+}
+interface UsePdfAnnotationsOptions {
+  isCommentsWanted?: MaybeRefOrGetter<boolean>;
+  onChange?: (change: PdfAnnotationChange) => void;
+  pdfDocument: MaybeRefOrGetter<PDFDocumentProxy | undefined>;
+  viewer: PdfViewerState;
+}
+export declare const usePdfAnnotations: ({ isCommentsWanted, onChange, pdfDocument, viewer }: UsePdfAnnotationsOptions) => PdfAnnotationsState;
+export type PdfApi = Pick<typeof PdfJs, "getDocument" | "GlobalWorkerOptions" | "PasswordResponses">;
+export type PdfDocumentParameters = Partial<Parameters<PdfApi["getDocument"]>[0]>;
+export interface PdfLoadingProgress {
+  loaded: number;
+  total: number;
+}
+export interface PdfDocumentState {
+  isFailed: Ref<boolean>;
+  isPasswordRequested: Ref<boolean>;
+  isPasswordWrong: Ref<boolean>;
+  pdfDocument: ShallowRef<PDFDocumentProxy | undefined>;
+  progress: Ref<PdfLoadingProgress>;
+  submitPassword: (password: string) => void;
+}
+export interface PdfRenderer {
+  api: PdfApi;
+  cMapUrl: string;
+  standardFontDataUrl: string;
+  wasmUrl: string;
+  workerSrc: string;
+}
+export type PdfSource = File | string | Uint8Array;
+interface UsePdfDocumentOptions {
+  parameters?: PdfDocumentParameters;
+  renderer: MaybeRefOrGetter<PdfRenderer | undefined>;
+  source: MaybeRefOrGetter<PdfSource | undefined>;
+}
+export declare const usePdfDocument: ({ parameters, renderer, source }: UsePdfDocumentOptions) => PdfDocumentState;
+interface UsePdfPageOptions {
+  canvas: MaybeRefOrGetter<HTMLCanvasElement | undefined>;
+  isActive?: MaybeRefOrGetter<boolean>;
+  isVisible?: MaybeRefOrGetter<boolean>;
+  pageNumber: MaybeRefOrGetter<number>;
+  pagesRotation?: MaybeRefOrGetter<number>;
+  pdfDocument: MaybeRefOrGetter<PDFDocumentProxy | undefined>;
+}
+export declare const usePdfPage: ({ canvas, isActive, isVisible, pageNumber, pagesRotation, pdfDocument }: UsePdfPageOptions) => void;
+export interface PdfThumbnail {
+  canvas: ShallowRef<HTMLCanvasElement | undefined>;
+  isCurrent: ComputedRef<boolean>;
+  isVisible: Ref<boolean>;
+  pageNumber: number;
+}
+interface UsePdfThumbnailsOptions {
+  currentPageNumber: MaybeRefOrGetter<number>;
+  pagesRotation: MaybeRefOrGetter<number>;
+  pdfDocument: MaybeRefOrGetter<PDFDocumentProxy | undefined>;
+  root: MaybeRefOrGetter<HTMLElement | undefined>;
+}
+export declare const usePdfThumbnails: ({ currentPageNumber, pagesRotation, pdfDocument, root }: UsePdfThumbnailsOptions) => ShallowRef<PdfThumbnail[]>;
+export type PdfViewerApi = Pick<typeof PdfJsViewer, "EventBus" | "FindState" | "LinkTarget" | "PDFFindController" | "PDFLinkService" | "PDFViewer">;
+interface UsePdfViewerOptions {
+  container: MaybeRefOrGetter<HTMLDivElement | undefined>;
+  highlightTerms?: MaybeRefOrGetter<string[]>;
+  imageResourcesPath: string;
+  pdfDocument: MaybeRefOrGetter<PDFDocumentProxy | undefined>;
+  viewer: MaybeRefOrGetter<HTMLDivElement | undefined>;
+  viewerApi: MaybeRefOrGetter<PdfViewerApi | undefined>;
+}
+export declare const usePdfViewer: ({ container, highlightTerms, imageResourcesPath, pdfDocument, viewer, viewerApi }: UsePdfViewerOptions) => PdfViewerState;
+interface UsePdfZoomGestureOptions {
+  container: MaybeRefOrGetter<HTMLDivElement | undefined>;
+  getViewer: () => PDFViewer | undefined;
+}
+export declare const usePdfZoomGesture: ({ container, getViewer }: UsePdfZoomGestureOptions) => void;
+export interface PdfFreeText {
+  contents: string;
+  id: string;
+  pageNumber: number;
+  rect: [number, number, number, number];
+}
+export interface PdfFreeTextEntry {
+  annotationType: PdfEditorMode.FreeText;
+  color: number[];
+  deleted: false;
+  fontSize: number;
+  id: string;
+  pageIndex: number;
+  rect: [number, number, number, number];
+  rotation: 0;
+  value: string;
+}
+export declare const PDF_MAX_CANVAS_AREA = 16777216;
+export declare const PDF_MIN_SCALE = .1;
+export declare const PDF_MAX_SCALE = 10;
+export declare const PDF_ZOOM_STEP = 1.1;
+export declare const PDF_OPENING_SCALE = "auto";
+export declare const PDF_ROTATION_STEP = 90;
+export declare const PDF_FULL_TURN = 360;
+export declare const PDF_PRINT_SCALE = 2;
+export declare const PDF_PRINT_BATCH_SIZE = 10;
+export declare const PDF_PRINT_CLASS = "pdf-print";
+export declare const PDF_MIME_TYPE = "application/pdf";
+export declare const PDF_EDITOR_KEY_PREFIX = "pdfjs_internal_editor_";
+export declare const PDF_FREE_TEXT_FONT_SIZE = 12;
+export declare const PDF_FREE_TEXT_COLOR: number[];
+export declare const PDF_WATERMARK_FONT_SIZE = 48;
+export declare const PDF_WATERMARK_COLOR: number[];
+export declare const PDF_PRINT_STYLE: string;
+export declare const PDF_WHEEL_ZOOM_DIVISOR = 500;
+interface CreateFreeTextEntryParameters {
+  color: number[];
+  fontSize: number;
+  id: string;
+  pageIndex: number;
+  rect: [number, number, number, number];
+  value: string;
+}
+export declare const createFreeTextEntry: ({ color, fontSize, id, pageIndex, rect, value }: CreateFreeTextEntryParameters) => PdfFreeTextEntry;
+export declare const destroyLoadingTask: (task: PDFDocumentLoadingTask) => void;
+interface Props {
+  cssWidth: number;
+  pageHeight: number;
+  pageWidth: number;
+  pixelRatio: number;
+}
+export declare const getCanvasScale: ({ cssWidth, pageHeight, pageWidth, pixelRatio }: Props) => number;
+export declare const getDownloadBytes: (pdfDocument: PDFDocumentProxy, watermark: string | undefined) => Promise<Uint8Array<ArrayBuffer>>;
+export declare const getPdfPages: (pdfDocument: PDFDocumentProxy) => Promise<PDFPageProxy[]>;
+export declare const getSourceParameters: (source: PdfSource) => Promise<{
+  data: Uint8Array;
+} | {
+  url: string;
+}>;
+export declare const getZoomedScroll: ({ point, ratio, scroll }: {
+  point: number;
+  ratio: number;
+  scroll: number;
+}) => number;
+export declare const loadPdfDocument: (renderer: PdfRenderer, source: PdfSource, parameters: PdfDocumentParameters) => Promise<PDFDocumentLoadingTask>;
+export declare const renderPrintImage: (pdfDocument: PDFDocumentProxy, pageNumber: number) => Promise<HTMLImageElement>;
+export declare const renderPrintSheets: (pdfDocument: PDFDocumentProxy, checkIsCancelled: () => boolean) => Promise<HTMLDivElement | undefined>;
+export declare const readXfdf: (xfdf: string, takenIds: ReadonlySet<string>) => Result<PdfFreeText[], string>;
+export declare const writeXfdf: (freeTexts: PdfFreeText[]) => string;
+export {};

package/dist/index.js

@@ -0,0 +1,898 @@
+import { Result, err, ok } from "neverthrow";
+import { downloadFile, getResultAsync, getSynchronizedFunction, noop, withFinalizerAsync } from "@esposter/shared";
+import { computed, effectScope, onScopeDispose, ref, shallowRef, toValue, watch } from "vue";
+// src/models/PdfEditorMode.ts
+let PdfEditorMode = /* @__PURE__ */ function(PdfEditorMode) {
+	PdfEditorMode[PdfEditorMode["None"] = 0] = "None";
+	PdfEditorMode[PdfEditorMode["FreeText"] = 3] = "FreeText";
+	PdfEditorMode[PdfEditorMode["Highlight"] = 9] = "Highlight";
+	PdfEditorMode[PdfEditorMode["Stamp"] = 13] = "Stamp";
+	PdfEditorMode[PdfEditorMode["Ink"] = 15] = "Ink";
+	return PdfEditorMode;
+}({});
+// src/services/constants.ts
+const PDF_MAX_CANVAS_AREA = 16777216;
+const PDF_MIN_SCALE = .1;
+const PDF_MAX_SCALE = 10;
+const PDF_ZOOM_STEP = 1.1;
+const PDF_OPENING_SCALE = "auto";
+const PDF_ROTATION_STEP = 90;
+const PDF_FULL_TURN = 360;
+const PDF_PRINT_SCALE = 2;
+const PDF_PRINT_BATCH_SIZE = 10;
+const PDF_PRINT_CLASS = "pdf-print";
+const PDF_MIME_TYPE = "application/pdf";
+const PDF_EDITOR_KEY_PREFIX = "pdfjs_internal_editor_";
+const PDF_FREE_TEXT_FONT_SIZE = 12;
+const PDF_FREE_TEXT_COLOR = [
+	0,
+	0,
+	0
+];
+const PDF_WATERMARK_FONT_SIZE = 48;
+const PDF_WATERMARK_COLOR = [
+	128,
+	128,
+	128
+];
+const PDF_PRINT_STYLE = `@page { margin: 3mm } .${PDF_PRINT_CLASS} { display: none } .${PDF_PRINT_CLASS} img { display: block; page-break-after: always; width: 100% } @media print { .${PDF_PRINT_CLASS} { display: block } body > :not(.${PDF_PRINT_CLASS}) { display: none !important } }`;
+const PDF_WHEEL_ZOOM_DIVISOR = 500;
+// src/services/createFreeTextEntry.ts
+const createFreeTextEntry = ({ color, fontSize, id, pageIndex, rect, value }) => ({
+	annotationType: 3,
+	color,
+	deleted: false,
+	fontSize,
+	id,
+	pageIndex,
+	rect,
+	rotation: 0,
+	value
+});
+// src/services/getPdfPages.ts
+const getPdfPages = (pdfDocument) => Promise.all(Array.from({ length: pdfDocument.numPages }, (_value, pageIndex) => pdfDocument.getPage(pageIndex + 1)));
+// src/xfdf/readXfdf.ts
+const parseCoordinate = (text) => text.trim() === "" ? NaN : Number(text);
+const checkRectangle = (coordinates) => coordinates.length === 4 && coordinates.every((coordinate) => Number.isFinite(coordinate));
+const readFreeText = (element, index, usedIds) => {
+	const page = element.getAttribute("page") ?? "";
+	const coordinates = (element.getAttribute("rect") ?? "").split(",").map((text) => parseCoordinate(text));
+	if (!/^\d+$/u.test(page)) return err(`Free text ${index + 1} has no valid page`);
+	if (!checkRectangle(coordinates)) return err(`Free text ${index + 1} has no valid rect`);
+	const contents = element.querySelector("contents")?.textContent ?? "";
+	if (contents.trim() === "") return err(`Free text ${index + 1} has no contents`);
+	const name = element.getAttribute("name") ?? "";
+	const id = name === "" || usedIds.has(name) ? crypto.randomUUID() : name;
+	usedIds.add(id);
+	return ok({
+		contents,
+		id,
+		pageNumber: Number(page) + 1,
+		rect: coordinates
+	});
+};
+const readXfdf = (xfdf, takenIds) => {
+	const xfdfDocument = new DOMParser().parseFromString(xfdf, "application/xml");
+	if (xfdfDocument.querySelector("parsererror")) return err("The XFDF is not well-formed XML");
+	const usedIds = new Set(takenIds);
+	return Result.combine(Array.from(xfdfDocument.querySelectorAll("freetext"), (element, index) => readFreeText(element, index, usedIds)));
+};
+// src/xfdf/writeXfdf.ts
+const escapeXml = (text) => text.replaceAll(/[\u0000-\u0008\u000B\u000C\u000E-\u001F]/gu, "").replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("\"", "&quot;");
+const writeXfdf = (freeTexts) => {
+	return `<?xml version="1.0" encoding="UTF-8"?>\n<xfdf xmlns="http://ns.adobe.com/xfdf/" xml:space="preserve"><annots>${freeTexts.map(({ contents, id, pageNumber, rect }) => `<freetext name="${escapeXml(id)}" page="${pageNumber - 1}" rect="${rect.join(",")}"><contents>${escapeXml(contents)}</contents></freetext>`).join("")}</annots></xfdf>`;
+};
+// src/composables/usePdfAnnotations.ts
+const readComments = async (loaded) => {
+	const pages = await getPdfPages(loaded);
+	return (await Promise.all(pages.map(async (page, pageIndex) => {
+		const annotations = await page.getAnnotations();
+		page.cleanup();
+		return annotations.filter(({ subtype }) => subtype === "Text").map(({ contentsObj }) => ({
+			contents: contentsObj?.str ?? "",
+			pageNumber: pageIndex + 1
+		}));
+	}))).flat();
+};
+const setEditorHook = (loaded, onEditor) => {
+	Object.assign(loaded.annotationStorage, { onAnnotationEditor: onEditor });
+};
+const readFreeTexts = (loaded) => Array.from(loaded.annotationStorage, ([key, value]) => {
+	const data = typeof value.serialize === "function" ? value.serialize() : value;
+	if (data?.annotationType !== 3 || !data.rect) return [];
+	const id = data.id ?? key.slice(22);
+	return [{
+		contents: data.value ?? "",
+		id,
+		pageNumber: (data.pageIndex ?? 0) + 1,
+		rect: data.rect
+	}];
+}).flat();
+const storeFreeTexts = (loaded, freeTexts) => {
+	for (const { contents, id, pageNumber, rect } of freeTexts) loaded.annotationStorage.setValue(`${PDF_EDITOR_KEY_PREFIX}xfdf${id}`, {
+		...createFreeTextEntry({
+			color: PDF_FREE_TEXT_COLOR,
+			fontSize: 12,
+			id,
+			pageIndex: pageNumber - 1,
+			rect,
+			value: contents
+		}),
+		isClone: true,
+		isCopy: true
+	});
+};
+const usePdfAnnotations = ({ isCommentsWanted = false, onChange, pdfDocument, viewer }) => {
+	const comments = shallowRef();
+	const loadComments = getSynchronizedFunction(async (loaded) => {
+		await getResultAsync(async () => {
+			const loadedComments = await readComments(loaded);
+			if (loaded === toValue(pdfDocument)) comments.value = loadedComments;
+		}).match(noop, (error) => {
+			console.error(error);
+			if (loaded === toValue(pdfDocument)) comments.value = [];
+		});
+	});
+	const setEditorMode = (mode) => {
+		viewer.editorMode.value = mode;
+	};
+	const exportXfdf = () => {
+		const loaded = toValue(pdfDocument);
+		return writeXfdf(loaded ? readFreeTexts(loaded) : []);
+	};
+	const importXfdf = (xfdf) => {
+		const loaded = toValue(pdfDocument);
+		if (!loaded) return err("No document is open to import into");
+		return readXfdf(xfdf, new Set(readFreeTexts(loaded).map(({ id }) => id))).andThen((freeTexts) => {
+			const stray = freeTexts.find(({ pageNumber }) => pageNumber > loaded.numPages);
+			if (stray) return err(`The XFDF has a free text on page ${stray.pageNumber}, and the document ends at page ${loaded.numPages}`);
+			storeFreeTexts(loaded, freeTexts);
+			viewer.drawStoredEditors();
+			return ok(void 0);
+		});
+	};
+	watch(() => toValue(pdfDocument), (loaded) => {
+		comments.value = void 0;
+		if (!loaded) return;
+		setEditorHook(loaded, (kind) => {
+			if (kind === null) return;
+			const drawn = [...loaded.annotationStorage].at(-1)?.[1];
+			if (drawn) onChange?.({
+				kind,
+				pageNumber: drawn.pageIndex + 1
+			});
+		});
+	}, { immediate: true });
+	let commentsDocument;
+	watch([() => toValue(pdfDocument), () => toValue(isCommentsWanted)], ([loaded, isWanted]) => {
+		if (!loaded || !isWanted || loaded === commentsDocument) return;
+		commentsDocument = loaded;
+		loadComments(loaded);
+	}, { immediate: true });
+	return {
+		comments,
+		exportXfdf,
+		importXfdf,
+		setEditorMode
+	};
+};
+// src/services/destroyLoadingTask.ts
+const destroyLoadingTask = getSynchronizedFunction(async (task) => {
+	await task.destroy();
+});
+// src/services/getSourceParameters.ts
+const getSourceParameters = async (source) => {
+	if (typeof source === "string") return { url: source };
+	if (source instanceof File) return { data: new Uint8Array(await source.arrayBuffer()) };
+	return { data: new Uint8Array(source) };
+};
+// src/services/loadPdfDocument.ts
+const loadPdfDocument = async (renderer, source, parameters) => {
+	renderer.api.GlobalWorkerOptions.workerSrc = renderer.workerSrc;
+	const sourceParameters = await getSourceParameters(source);
+	return renderer.api.getDocument({
+		cMapPacked: true,
+		cMapUrl: renderer.cMapUrl,
+		standardFontDataUrl: renderer.standardFontDataUrl,
+		wasmUrl: renderer.wasmUrl,
+		...parameters,
+		...sourceParameters
+	});
+};
+// src/composables/usePdfDocument.ts
+const EMPTY_PROGRESS = {
+	loaded: 0,
+	total: 0
+};
+const usePdfDocument = ({ parameters = {}, renderer, source }) => {
+	const pdfDocument = shallowRef();
+	const progress = ref(EMPTY_PROGRESS);
+	const isFailed = ref(false);
+	const isPasswordRequested = ref(false);
+	const isPasswordWrong = ref(false);
+	let loadingTask;
+	let updatePassword;
+	let loadGeneration = 0;
+	const destroyCurrentTask = () => {
+		if (loadingTask) destroyLoadingTask(loadingTask);
+		loadingTask = void 0;
+	};
+	const release = () => {
+		loadGeneration++;
+		destroyCurrentTask();
+		pdfDocument.value = void 0;
+		progress.value = EMPTY_PROGRESS;
+		isFailed.value = false;
+		isPasswordRequested.value = false;
+		isPasswordWrong.value = false;
+	};
+	const load = async (currentRenderer, currentSource) => {
+		const generation = loadGeneration;
+		await getResultAsync(async () => {
+			const task = await loadPdfDocument(currentRenderer, currentSource, parameters);
+			if (generation !== loadGeneration) {
+				destroyLoadingTask(task);
+				return;
+			}
+			loadingTask = task;
+			task.onProgress = ({ loaded, total }) => {
+				if (generation === loadGeneration) progress.value = {
+					loaded,
+					total
+				};
+			};
+			task.onPassword = (passwordCallback, reason) => {
+				if (generation !== loadGeneration) return;
+				updatePassword = passwordCallback;
+				isPasswordWrong.value = reason === currentRenderer.api.PasswordResponses.INCORRECT_PASSWORD;
+				isPasswordRequested.value = true;
+			};
+			const loadedDocument = await task.promise;
+			if (generation === loadGeneration) pdfDocument.value = loadedDocument;
+		}).match(noop, (error) => {
+			if (generation !== loadGeneration) return;
+			isFailed.value = true;
+			destroyCurrentTask();
+			console.error(error);
+		});
+	};
+	const submitPassword = (password) => {
+		isPasswordRequested.value = false;
+		updatePassword?.(password);
+	};
+	watch([() => toValue(renderer), () => toValue(source)], getSynchronizedFunction(async ([currentRenderer, currentSource]) => {
+		release();
+		if (currentRenderer && currentSource) await load(currentRenderer, currentSource);
+	}), { immediate: true });
+	onScopeDispose(release);
+	return {
+		isFailed,
+		isPasswordRequested,
+		isPasswordWrong,
+		pdfDocument,
+		progress,
+		submitPassword
+	};
+};
+// src/services/getCanvasScale.ts
+const getCanvasScale = ({ cssWidth, pageHeight, pageWidth, pixelRatio }) => {
+	const scale = cssWidth / pageWidth * pixelRatio;
+	if (pageWidth * pageHeight * scale ** 2 <= 16777216) return scale;
+	return Math.sqrt(PDF_MAX_CANVAS_AREA / (pageWidth * pageHeight));
+};
+// src/composables/usePdfPage.ts
+const usePdfPage = ({ canvas, isActive = true, isVisible = true, pageNumber, pagesRotation = 0, pdfDocument }) => {
+	let cssWidth = 0;
+	let loadGeneration = 0;
+	let page;
+	let renderTask;
+	const awaitRender = getSynchronizedFunction(async (task) => {
+		await getResultAsync(() => task.promise).match(noop, (error) => {
+			if (task === renderTask) console.error(error);
+		});
+	});
+	const cancelRender = () => {
+		renderTask?.cancel();
+		renderTask = void 0;
+	};
+	const drawPage = () => {
+		const currentCanvas = toValue(canvas);
+		if (!page || !currentCanvas || cssWidth === 0 || !toValue(isVisible)) return;
+		cancelRender();
+		const rotation = (page.rotate + toValue(pagesRotation)) % 360;
+		const { height, width } = page.getViewport({
+			rotation,
+			scale: 1
+		});
+		const viewport = page.getViewport({
+			rotation,
+			scale: getCanvasScale({
+				cssWidth,
+				pageHeight: height,
+				pageWidth: width,
+				pixelRatio: window.devicePixelRatio
+			})
+		});
+		currentCanvas.width = viewport.width;
+		currentCanvas.height = viewport.height;
+		const task = page.render({
+			canvas: currentCanvas,
+			viewport
+		});
+		renderTask = task;
+		awaitRender(task);
+	};
+	const isWanted = ref(false);
+	watch(() => toValue(isActive), (active) => {
+		if (active) isWanted.value = true;
+	}, { immediate: true });
+	watch([
+		() => toValue(pdfDocument),
+		() => toValue(pageNumber),
+		isWanted
+	], getSynchronizedFunction(async ([currentDocument, currentPageNumber, currentIsWanted]) => {
+		const generation = ++loadGeneration;
+		cancelRender();
+		page = void 0;
+		if (!currentDocument || !currentIsWanted) return;
+		await getResultAsync(async () => {
+			const loadedPage = await currentDocument.getPage(currentPageNumber);
+			if (generation !== loadGeneration) return;
+			page = loadedPage;
+			drawPage();
+		}).match(noop, (error) => {
+			if (generation === loadGeneration) console.error(error);
+		});
+	}), { immediate: true });
+	watch(() => toValue(canvas), (currentCanvas, _previousCanvas, onCleanup) => {
+		if (!currentCanvas) {
+			cancelRender();
+			return;
+		}
+		cssWidth = 0;
+		const observer = new ResizeObserver((entries) => {
+			const width = entries[0]?.contentRect.width ?? 0;
+			if (width === cssWidth) return;
+			cssWidth = width;
+			drawPage();
+		});
+		observer.observe(currentCanvas);
+		onCleanup(() => {
+			observer.disconnect();
+		});
+	}, { immediate: true });
+	watch(() => toValue(isVisible), (visible) => {
+		if (visible) drawPage();
+	});
+	watch(() => toValue(pagesRotation), () => {
+		drawPage();
+	});
+	onScopeDispose(() => {
+		loadGeneration++;
+		cancelRender();
+		page?.cleanup();
+	});
+};
+// src/composables/usePdfThumbnails.ts
+const usePdfThumbnails = ({ currentPageNumber, pagesRotation, pdfDocument, root }) => {
+	const thumbnails = shallowRef([]);
+	const rows = /* @__PURE__ */ new Map();
+	let observer;
+	let scope;
+	const createThumbnail = (pageNumber, currentDocument) => {
+		const canvas = shallowRef();
+		const isVisible = ref(false);
+		const thumbnail = {
+			canvas,
+			isCurrent: computed(() => toValue(currentPageNumber) === pageNumber),
+			isVisible,
+			pageNumber
+		};
+		usePdfPage({
+			canvas: () => canvas.value,
+			isActive: () => isVisible.value,
+			isVisible: () => isVisible.value,
+			pageNumber,
+			pagesRotation: () => toValue(pagesRotation),
+			pdfDocument: currentDocument
+		});
+		watch(canvas, (element, _previousElement, onCleanup) => {
+			if (!element) return;
+			rows.set(element, thumbnail);
+			observer?.observe(element);
+			onCleanup(() => {
+				observer?.unobserve(element);
+				rows.delete(element);
+			});
+		});
+		return thumbnail;
+	};
+	watch(() => toValue(root), (rootElement) => {
+		observer?.disconnect();
+		observer = new IntersectionObserver((entries) => {
+			for (const entry of entries) {
+				const row = rows.get(entry.target);
+				if (row) row.isVisible.value = entry.isIntersecting;
+			}
+		}, { root: rootElement ?? null });
+		for (const element of rows.keys()) observer.observe(element);
+	}, { immediate: true });
+	watch(() => toValue(pdfDocument), (loaded) => {
+		scope?.stop();
+		rows.clear();
+		thumbnails.value = [];
+		if (!loaded) return;
+		scope = effectScope();
+		thumbnails.value = scope.run(() => Array.from({ length: loaded.numPages }, (_value, index) => createThumbnail(index + 1, loaded))) ?? [];
+	}, { immediate: true });
+	onScopeDispose(() => {
+		scope?.stop();
+		observer?.disconnect();
+	});
+	return thumbnails;
+};
+// src/services/getZoomedScroll.ts
+const getZoomedScroll = ({ point, ratio, scroll }) => (scroll + point) * ratio - point;
+// src/composables/usePdfZoomGesture.ts
+const usePdfZoomGesture = ({ container, getViewer }) => {
+	const abortController = new AbortController();
+	const pointers = /* @__PURE__ */ new Map();
+	let pinchDistance = 0;
+	const measurePinch = () => {
+		const [first, second] = [...pointers.values()];
+		if (pointers.size !== 2 || !first || !second) return void 0;
+		return {
+			distance: Math.hypot(second.x - first.x, second.y - first.y),
+			point: {
+				x: (first.x + second.x) / 2,
+				y: (first.y + second.y) / 2
+			}
+		};
+	};
+	const measurePinchDistance = () => measurePinch()?.distance ?? 0;
+	const zoomAbout = (ratio, point) => {
+		const viewer = getViewer();
+		const element = toValue(container);
+		if (!viewer || !element) return;
+		const { currentScale } = viewer;
+		const nextScale = Math.min(Math.max(currentScale * ratio, PDF_MIN_SCALE), 10);
+		const scaleRatio = nextScale / currentScale;
+		const { left, top } = element.getBoundingClientRect();
+		const { scrollLeft, scrollTop } = element;
+		viewer.currentScale = nextScale;
+		element.scrollLeft = getZoomedScroll({
+			point: point.x - left,
+			ratio: scaleRatio,
+			scroll: scrollLeft
+		});
+		element.scrollTop = getZoomedScroll({
+			point: point.y - top,
+			ratio: scaleRatio,
+			scroll: scrollTop
+		});
+	};
+	const onPointerDown = (event) => {
+		pointers.set(event.pointerId, {
+			x: event.clientX,
+			y: event.clientY
+		});
+		pinchDistance = measurePinchDistance();
+	};
+	const onPointerMove = (event) => {
+		if (!pointers.has(event.pointerId)) return;
+		pointers.set(event.pointerId, {
+			x: event.clientX,
+			y: event.clientY
+		});
+		const pinch = measurePinch();
+		if (pinch && pinchDistance > 0) zoomAbout(pinch.distance / pinchDistance, pinch.point);
+		pinchDistance = pinch?.distance ?? 0;
+	};
+	const onPointerEnd = (event) => {
+		pointers.delete(event.pointerId);
+		pinchDistance = measurePinchDistance();
+	};
+	const onWheel = (event) => {
+		if (!event.ctrlKey) return;
+		event.preventDefault();
+		zoomAbout(Math.exp(-event.deltaY / 500), {
+			x: event.clientX,
+			y: event.clientY
+		});
+	};
+	watch(() => toValue(container), (element) => {
+		if (!element) return;
+		const { signal } = abortController;
+		element.addEventListener("pointerdown", (event) => {
+			onPointerDown(event);
+		}, { signal });
+		element.addEventListener("pointermove", (event) => {
+			onPointerMove(event);
+		}, { signal });
+		element.addEventListener("pointerup", (event) => {
+			onPointerEnd(event);
+		}, { signal });
+		element.addEventListener("pointercancel", (event) => {
+			onPointerEnd(event);
+		}, { signal });
+		element.addEventListener("pointerleave", (event) => {
+			onPointerEnd(event);
+		}, { signal });
+		element.addEventListener("wheel", (event) => {
+			onWheel(event);
+		}, {
+			passive: false,
+			signal
+		});
+	}, { immediate: true });
+	onScopeDispose(() => {
+		abortController.abort();
+	});
+};
+// src/services/getDownloadBytes.ts
+const addWatermark = async (pdfDocument, watermark) => {
+	const { annotationStorage } = pdfDocument;
+	return (await getPdfPages(pdfDocument)).map((page, pageIndex) => {
+		const [left = 0, bottom = 0, right = 0, top = 0] = page.view;
+		page.cleanup();
+		const middle = (bottom + top) / 2;
+		const id = `watermark${pageIndex}`;
+		const key = `${PDF_EDITOR_KEY_PREFIX}${id}`;
+		annotationStorage.setValue(key, createFreeTextEntry({
+			color: PDF_WATERMARK_COLOR,
+			fontSize: 48,
+			id,
+			pageIndex,
+			rect: [
+				left,
+				middle - 24,
+				right,
+				middle + 24
+			],
+			value: watermark
+		}));
+		return key;
+	});
+};
+const getDownloadBytes = async (pdfDocument, watermark) => {
+	const { annotationStorage } = pdfDocument;
+	if (annotationStorage.size === 0 && !watermark) return new Uint8Array(await pdfDocument.getData());
+	const watermarkKeys = watermark ? await addWatermark(pdfDocument, watermark) : [];
+	return withFinalizerAsync(() => pdfDocument.saveDocument(), () => {
+		for (const key of watermarkKeys) annotationStorage.remove(key);
+	});
+};
+// src/services/renderPrintImage.ts
+const renderPrintImage = async (pdfDocument, pageNumber) => {
+	const page = await pdfDocument.getPage(pageNumber);
+	const { height, width } = page.getViewport({ scale: 1 });
+	const printScale = getCanvasScale({
+		cssWidth: width,
+		pageHeight: height,
+		pageWidth: width,
+		pixelRatio: 2
+	});
+	const viewport = page.getViewport({ scale: printScale });
+	const canvas = window.document.createElement("canvas");
+	canvas.width = viewport.width;
+	canvas.height = viewport.height;
+	await page.render({
+		canvas,
+		viewport
+	}).promise;
+	const image = window.document.createElement("img");
+	image.src = canvas.toDataURL("image/png");
+	return image;
+};
+// src/services/renderPrintSheets.ts
+const renderPrintSheets = async (pdfDocument, checkIsCancelled) => {
+	const style = window.document.createElement("style");
+	style.textContent = PDF_PRINT_STYLE;
+	const printRoot = window.document.createElement("div");
+	printRoot.className = PDF_PRINT_CLASS;
+	printRoot.append(style);
+	const renderBatch = async (firstPageNumber) => {
+		if (checkIsCancelled() || firstPageNumber > pdfDocument.numPages) return;
+		const lastPageNumber = Math.min(firstPageNumber + 10 - 1, pdfDocument.numPages);
+		const pageNumbers = Array.from({ length: lastPageNumber - firstPageNumber + 1 }, (_value, index) => firstPageNumber + index);
+		printRoot.append(...await Promise.all(pageNumbers.map((pageNumber) => renderPrintImage(pdfDocument, pageNumber))));
+		await renderBatch(lastPageNumber + 1);
+	};
+	await renderBatch(1);
+	return checkIsCancelled() ? void 0 : printRoot;
+};
+// src/composables/usePdfViewer.ts
+const usePdfViewer = ({ container, highlightTerms = [], imageResourcesPath, pdfDocument, viewer, viewerApi }) => {
+	const currentPageNumber = ref(0);
+	const editorMode = ref(0);
+	const isMatchCase = ref(false);
+	const isNotFound = ref(false);
+	const isWholeWord = ref(false);
+	const matchesCount = ref({
+		current: 0,
+		total: 0
+	});
+	const outline = shallowRef();
+	const overlays = shallowRef([]);
+	const pagesCount = ref(0);
+	const pagesRotation = ref(0);
+	const scale = ref(0);
+	const searchQuery = ref("");
+	const documentGeneration = ref(0);
+	const isZoomInDisabled = computed(() => scale.value >= 10);
+	const isZoomOutDisabled = computed(() => scale.value <= PDF_MIN_SCALE);
+	let abortController;
+	let eventBus;
+	let linkService;
+	let pdfViewer;
+	let resizeObserver;
+	let printRoot;
+	let printGeneration = 0;
+	let editorManager;
+	const applyEditorMode = () => {
+		if (pdfViewer && editorManager) pdfViewer.annotationEditorMode = { mode: editorMode.value };
+	};
+	const createViewer = (currentViewerApi, containerValue, viewerElement) => {
+		const { EventBus, FindState, LinkTarget, PDFFindController, PDFLinkService, PDFViewer } = currentViewerApi;
+		const bus = new EventBus();
+		const links = new PDFLinkService({
+			eventBus: bus,
+			externalLinkTarget: LinkTarget.BLANK
+		});
+		const controller = new PDFFindController({
+			eventBus: bus,
+			linkService: links
+		});
+		const viewerAbortController = new AbortController();
+		const { signal } = viewerAbortController;
+		const instance = new PDFViewer({
+			abortSignal: signal,
+			container: containerValue,
+			eventBus: bus,
+			findController: controller,
+			imageResourcesPath,
+			linkService: links,
+			maxCanvasPixels: PDF_MAX_CANVAS_AREA,
+			viewer: viewerElement
+		});
+		links.setViewer(instance);
+		abortController = viewerAbortController;
+		eventBus = bus;
+		linkService = links;
+		pdfViewer = instance;
+		bus.on("pagesinit", () => {
+			instance.currentScaleValue = PDF_OPENING_SCALE;
+		});
+		bus.on("annotationeditoruimanager", (event) => {
+			editorManager = event.uiManager;
+			applyEditorMode();
+		});
+		bus.on("pagechanging", (event) => {
+			currentPageNumber.value = event.pageNumber;
+		});
+		bus.on("pagerendered", (event) => {
+			const overlay = {
+				element: event.source.div,
+				pageNumber: event.pageNumber,
+				viewport: event.source.viewport
+			};
+			overlays.value = [...overlays.value.filter(({ pageNumber }) => pageNumber !== event.pageNumber), overlay];
+		});
+		bus.on("scalechanging", (event) => {
+			scale.value = event.scale;
+		});
+		bus.on("rotationchanging", (event) => {
+			pagesRotation.value = event.pagesRotation;
+		});
+		bus.on("updatefindcontrolstate", (event) => {
+			isNotFound.value = event.state === FindState.NOT_FOUND;
+			matchesCount.value = event.matchesCount;
+		});
+		bus.on("updatefindmatchescount", (event) => {
+			matchesCount.value = event.matchesCount;
+		});
+		resizeObserver = new ResizeObserver(() => {
+			if (!pdfViewer) return;
+			const { currentScaleValue } = pdfViewer;
+			if (currentScaleValue) pdfViewer.currentScaleValue = currentScaleValue;
+		});
+		resizeObserver.observe(containerValue);
+		window.addEventListener("afterprint", () => {
+			removePrint();
+		}, { signal });
+		applyDocument(toValue(pdfDocument));
+	};
+	const loadOutline = getSynchronizedFunction(async (loaded) => {
+		await getResultAsync(async () => {
+			const items = await loaded.getOutline();
+			if (loaded === toValue(pdfDocument)) outline.value = items ?? [];
+		}).match(noop, (error) => {
+			console.error(error);
+			if (loaded === toValue(pdfDocument)) outline.value = [];
+		});
+	});
+	const applyDocument = (loaded) => {
+		if (!pdfViewer || !linkService) return;
+		pagesCount.value = loaded?.numPages ?? 0;
+		overlays.value = [];
+		outline.value = void 0;
+		editorManager = void 0;
+		pdfViewer.setDocument(loaded ?? null);
+		linkService.setDocument(loaded ?? null);
+		currentPageNumber.value = 1;
+		pagesRotation.value = 0;
+		searchQuery.value = "";
+		matchesCount.value = {
+			current: 0,
+			total: 0
+		};
+		isNotFound.value = false;
+		if (!loaded) return;
+		loadOutline(loaded);
+		searchQuery.value = toValue(highlightTerms).join(" ");
+		documentGeneration.value++;
+	};
+	const findText = ({ isPrevious = false, query, type = "" }) => {
+		eventBus?.dispatch("find", {
+			caseSensitive: isMatchCase.value,
+			entireWord: isWholeWord.value,
+			findPrevious: isPrevious,
+			highlightAll: true,
+			matchDiacritics: false,
+			query,
+			type
+		});
+	};
+	watch([
+		searchQuery,
+		isMatchCase,
+		isWholeWord,
+		documentGeneration
+	], () => {
+		if (toValue(pdfDocument)) findText({ query: searchQuery.value });
+	});
+	const removePrint = () => {
+		printGeneration++;
+		printRoot?.remove();
+		printRoot = void 0;
+	};
+	const followBookmark = getSynchronizedFunction(async (item) => {
+		await getResultAsync(async () => {
+			if (item.dest) await linkService?.goToDestination(item.dest);
+		}).match(noop, console.error);
+	});
+	const goToPage = (pageNumber) => {
+		if (pdfViewer && Number.isInteger(pageNumber) && pageNumber >= 1 && pageNumber <= pagesCount.value) pdfViewer.currentPageNumber = pageNumber;
+	};
+	const previousPage = () => {
+		pdfViewer?.previousPage();
+	};
+	const nextPage = () => {
+		pdfViewer?.nextPage();
+	};
+	const zoomTo = (nextScale) => {
+		if (pdfViewer) pdfViewer.currentScale = Math.min(Math.max(nextScale, PDF_MIN_SCALE), 10);
+	};
+	const zoomIn = () => {
+		if (pdfViewer && pdfViewer.currentScale > 0) zoomTo(pdfViewer.currentScale * PDF_ZOOM_STEP);
+	};
+	const zoomOut = () => {
+		if (pdfViewer && pdfViewer.currentScale > 0) zoomTo(pdfViewer.currentScale / PDF_ZOOM_STEP);
+	};
+	const resetZoom = () => {
+		if (pdfViewer) pdfViewer.currentScaleValue = PDF_OPENING_SCALE;
+	};
+	const fitWidth = () => {
+		if (pdfViewer) pdfViewer.currentScaleValue = "page-width";
+	};
+	const fitPage = () => {
+		if (pdfViewer) pdfViewer.currentScaleValue = "page-fit";
+	};
+	const actualSize = () => {
+		if (pdfViewer) pdfViewer.currentScaleValue = "page-actual";
+	};
+	const rotate = (degrees) => {
+		if (pdfViewer) pdfViewer.pagesRotation = ((pdfViewer.pagesRotation + degrees) % 360 + 360) % 360;
+	};
+	const findNext = () => {
+		findText({
+			query: searchQuery.value,
+			type: "again"
+		});
+	};
+	const findPrevious = () => {
+		findText({
+			isPrevious: true,
+			query: searchQuery.value,
+			type: "again"
+		});
+	};
+	const download = getSynchronizedFunction(async (filename, watermark) => {
+		const downloaded = toValue(pdfDocument);
+		if (!downloaded) return;
+		await getResultAsync(async () => {
+			downloadFile(filename, await getDownloadBytes(downloaded, watermark), PDF_MIME_TYPE);
+		}).match(noop, console.error);
+	});
+	const print = getSynchronizedFunction(async () => {
+		const printed = toValue(pdfDocument);
+		if (!printed) return;
+		removePrint();
+		const generation = printGeneration;
+		await getResultAsync(async () => {
+			const sheets = await renderPrintSheets(printed, () => generation !== printGeneration);
+			if (!sheets) return;
+			window.document.body.append(sheets);
+			printRoot = sheets;
+			window.print();
+		}).match(noop, console.error);
+	});
+	const drawStoredEditors = getSynchronizedFunction(async () => {
+		const manager = editorManager;
+		if (!manager) return;
+		await getResultAsync(async () => {
+			await Promise.all(Array.from({ length: pagesCount.value }, async (_value, pageIndex) => {
+				const layer = manager.getLayer(pageIndex);
+				if (!layer) return;
+				await manager.findClonesForPage(layer);
+				layer.div.hidden = layer.isEmpty;
+			}));
+		}).match(noop, console.error);
+	});
+	usePdfZoomGesture({
+		container,
+		getViewer: () => pdfViewer
+	});
+	watch([
+		() => toValue(viewerApi),
+		() => toValue(container),
+		() => toValue(viewer)
+	], ([currentViewerApi, containerElementValue, viewerElement]) => {
+		if (pdfViewer || !currentViewerApi || !containerElementValue || !viewerElement) return;
+		createViewer(currentViewerApi, containerElementValue, viewerElement);
+	}, { immediate: true });
+	watch(() => toValue(pdfDocument), (loaded) => {
+		applyDocument(loaded);
+	});
+	watch(editorMode, applyEditorMode);
+	onScopeDispose(() => {
+		removePrint();
+		if (!pdfViewer) return;
+		pdfViewer.setDocument(null);
+		abortController?.abort();
+		resizeObserver?.disconnect();
+	});
+	return {
+		actualSize,
+		currentPageNumber,
+		download,
+		drawStoredEditors,
+		editorMode,
+		findNext,
+		findPrevious,
+		fitPage,
+		fitWidth,
+		followBookmark,
+		goToPage,
+		isMatchCase,
+		isNotFound,
+		isWholeWord,
+		isZoomInDisabled,
+		isZoomOutDisabled,
+		matchesCount,
+		nextPage,
+		outline,
+		overlays,
+		pagesCount,
+		pagesRotation,
+		previousPage,
+		print,
+		resetZoom,
+		rotate,
+		scale,
+		searchQuery,
+		zoomIn,
+		zoomOut
+	};
+};
+export { PDF_EDITOR_KEY_PREFIX, PDF_FREE_TEXT_COLOR, PDF_FREE_TEXT_FONT_SIZE, PDF_FULL_TURN, PDF_MAX_CANVAS_AREA, PDF_MAX_SCALE, PDF_MIME_TYPE, PDF_MIN_SCALE, PDF_OPENING_SCALE, PDF_PRINT_BATCH_SIZE, PDF_PRINT_CLASS, PDF_PRINT_SCALE, PDF_PRINT_STYLE, PDF_ROTATION_STEP, PDF_WATERMARK_COLOR, PDF_WATERMARK_FONT_SIZE, PDF_WHEEL_ZOOM_DIVISOR, PDF_ZOOM_STEP, PdfEditorMode, createFreeTextEntry, destroyLoadingTask, getCanvasScale, getDownloadBytes, getPdfPages, getSourceParameters, getZoomedScroll, loadPdfDocument, readXfdf, renderPrintImage, renderPrintSheets, usePdfAnnotations, usePdfDocument, usePdfPage, usePdfThumbnails, usePdfViewer, usePdfZoomGesture, writeXfdf };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vue-pdfjs-headless",
-  "version": "4.4.0",
+  "version": "4.6.0",
   "description": "Headless Vue composables over pdfjs-dist: a document's loading, a page's drawing and the viewer's state, with no styling and no renderer of its own.",
   "keywords": [
     "headless",
@@ -46,18 +46,18 @@
     "typecheck": "tsrs --fast"
   },
   "dependencies": {
-    "@esposter/shared": "4.4.0",
+    "@esposter/shared": "4.6.0",
     "neverthrow": "^8.2.0"
   },
   "devDependencies": {
-    "@esposter/configuration": "4.4.0",
+    "@esposter/configuration": "4.6.0",
     "@vue/test-utils": "^2.5.1",
     "happy-dom": "^21.0.4",
-    "tsdown": "0.23.2"
+    "tsdown": "^0.23.7"
   },
   "peerDependencies": {
-    "pdfjs-dist": "^6.4.299",
-    "vue": "^3.5.44"
+    "pdfjs-dist": "^6.5.438",
+    "vue": "^3.5.45"
   },
-  "gitHead": "e1a416c4b91da69cc2aa259b50a4d656f204d272"
+  "gitHead": "0ceea3ffbe12ca69413ea5db2d3cfad197a63cba"
 }