svelte-pdf-view 0.1.13 → 0.2.0

package/dist/PdfRenderer.svelte

@@ -7,6 +7,7 @@
 		type PdfSource
 	} from './pdf-viewer/context.js';
 	import { getPdfJs } from './pdf-viewer/pdfjs-singleton.js';
+	import { PdfPresentationMode } from './pdf-viewer/PdfPresentationMode.js';
 	import { rendererStyles } from './pdf-viewer/renderer-styles.js';
 
 	interface Props {
@@ -51,6 +52,17 @@
 	let viewer: import('./pdf-viewer/PDFViewerCore.js').PDFViewerCore | null = null;
 	let findController: import('./pdf-viewer/FindController.js').FindController | null = null;
 
+	// Presentation mode
+	const presentationMode = new PdfPresentationMode({
+		onStateChange: (newState) => {
+			viewerState.presentationMode = newState;
+		},
+		onPageChange: (pageNumber) => {
+			// Sync page number back to main viewer when changed in presentation mode
+			viewer?.scrollToPage(pageNumber);
+		}
+	});
+
 	async function loadPdf(source: PdfSource) {
 		if (!BROWSER || !scrollContainerEl) return;
 
@@ -127,10 +139,13 @@
 			}
 
 			const loadingTask = pdfjs.getDocument(documentSource);
-			const pdfDocument = await loadingTask.promise;
+			const loadedPdfDocument = await loadingTask.promise;
 
-			await newViewer.setDocument(pdfDocument);
-			findController.setDocument(pdfDocument);
+			await newViewer.setDocument(loadedPdfDocument);
+			findController.setDocument(loadedPdfDocument);
+
+			// Set document on presentation mode
+			presentationMode.setDocument(loadedPdfDocument);
 
 			viewer = newViewer;
 			viewerState.loading = false;
@@ -174,7 +189,14 @@
 				viewerState.searchTotal = 0;
 			}
 		},
-		download: async () => {} // Download is handled by PdfViewer, not renderer
+		download: async () => {}, // Download is handled by PdfViewer, not renderer
+		enterPresentationMode: async () => {
+			presentationMode.setCurrentPage(viewerState.currentPage);
+			return presentationMode.request();
+		},
+		exitPresentationMode: async () => {
+			await presentationMode.exit();
+		}
 	};
 
 	onMount(async () => {
@@ -225,6 +247,7 @@
 			viewer = null;
 		}
 		findController = null;
+		presentationMode.destroy();
 		// Note: Worker is a global singleton, not cleaned up per-component
 		// Use destroyPdfJs() from pdfjs-singleton.js if you need to fully cleanup
 	});

package/dist/PdfToolbar.svelte

@@ -7,7 +7,8 @@
 		Search,
 		ChevronLeft,
 		ChevronRight,
-		Download
+		Download,
+		Presentation
 	} from '@lucide/svelte';
 	import { getPdfViewerContext } from './pdf-viewer/context.js';
 
@@ -116,8 +117,15 @@
 		{/if}
 	</div>
 
-	<!-- Download -->
+	<!-- Presentation & Download -->
 	<div class="pdf-toolbar-group">
+		<button
+			onclick={() => actions.enterPresentationMode()}
+			aria-label="Presentation Mode"
+			title="Presentation Mode"
+		>
+			<Presentation size={18} />
+		</button>
 		<button onclick={() => actions.download()} aria-label="Download PDF" title="Download">
 			<Download size={18} />
 		</button>

package/dist/PdfViewer.svelte

@@ -8,6 +8,7 @@
 	import type { Snippet } from 'svelte';
 	import {
 		setPdfViewerContext,
+		PresentationModeState,
 		type PdfViewerState,
 		type PdfViewerActions,
 		type PdfSource
@@ -52,7 +53,8 @@
 		searchQuery: '',
 		searchCurrent: 0,
 		searchTotal: 0,
-		isSearching: false
+		isSearching: false,
+		presentationMode: PresentationModeState.NORMAL
 	});
 
 	// Renderer actions - will be populated when renderer mounts
@@ -116,7 +118,18 @@
 		searchNext: () => rendererActions?.searchNext(),
 		searchPrevious: () => rendererActions?.searchPrevious(),
 		clearSearch: () => rendererActions?.clearSearch(),
-		download: downloadPdf
+		download: downloadPdf,
+		enterPresentationMode: async () => {
+			if (rendererActions) {
+				return rendererActions.enterPresentationMode();
+			}
+			return false;
+		},
+		exitPresentationMode: async () => {
+			if (rendererActions) {
+				await rendererActions.exitPresentationMode();
+			}
+		}
 	};
 
 	// Set up context

package/dist/index.d.ts

@@ -1,4 +1,4 @@
 export { default as PdfViewer, Toolbar as PdfToolbar, Renderer as PdfRenderer } from './PdfViewer.svelte';
 export type { PdfSource } from './pdf-viewer/context.js';
-export { getPdfViewerContext, type PdfViewerState, type PdfViewerActions, type PdfViewerContext } from './pdf-viewer/context.js';
+export { getPdfViewerContext, PresentationModeState, type PdfViewerState, type PdfViewerActions, type PdfViewerContext } from './pdf-viewer/context.js';
 export { destroyPdfJs } from './pdf-viewer/pdfjs-singleton.js';

package/dist/index.js

@@ -1,6 +1,6 @@
 // Reexport your entry components here
 export { default as PdfViewer, Toolbar as PdfToolbar, Renderer as PdfRenderer } from './PdfViewer.svelte';
 // Export context for custom toolbars
-export { getPdfViewerContext } from './pdf-viewer/context.js';
+export { getPdfViewerContext, PresentationModeState } from './pdf-viewer/context.js';
 // Export PDF.js singleton utilities
 export { destroyPdfJs } from './pdf-viewer/pdfjs-singleton.js';

package/dist/pdf-viewer/PdfPresentationMode.d.ts

@@ -0,0 +1,96 @@
+/**
+ * PdfPresentationMode - Fullscreen presentation mode for PDF viewing.
+ * This is a derivative work based on PDF.js pdf_presentation_mode.js
+ *
+ * Features:
+ * - Browser fullscreen mode
+ * - Black background
+ * - Single page view scaled to fit screen
+ * - No text layer or toolbar
+ * - Mouse/keyboard/touch navigation
+ */
+import type { PDFDocumentProxy } from 'pdfjs-dist/legacy/build/pdf.mjs';
+export declare enum PresentationModeState {
+    UNKNOWN = 0,
+    NORMAL = 1,
+    CHANGING = 2,
+    FULLSCREEN = 3
+}
+export interface PresentationModeCallbacks {
+    onStateChange?: (state: PresentationModeState) => void;
+    onPageChange?: (pageNumber: number) => void;
+}
+export declare class PdfPresentationMode {
+    private state;
+    private pdfDocument;
+    private currentPageNumber;
+    private totalPages;
+    private container;
+    private canvas;
+    private callbacks;
+    private fullscreenChangeAbortController;
+    private windowAbortController;
+    private mouseScrollTimeStamp;
+    private mouseScrollDelta;
+    private touchSwipeState;
+    private renderingPage;
+    constructor(callbacks?: PresentationModeCallbacks);
+    /**
+     * Set the PDF document for presentation
+     */
+    setDocument(pdfDocument: PDFDocumentProxy | null): void;
+    /**
+     * Set the current page number (used when entering presentation mode)
+     */
+    setCurrentPage(pageNumber: number): void;
+    /**
+     * Check if presentation mode is active
+     */
+    get active(): boolean;
+    /**
+     * Get current state
+     */
+    get currentState(): PresentationModeState;
+    /**
+     * Request entering fullscreen presentation mode
+     */
+    request(): Promise<boolean>;
+    /**
+     * Exit presentation mode
+     */
+    exit(): Promise<void>;
+    /**
+     * Go to next page
+     */
+    nextPage(): boolean;
+    /**
+     * Go to previous page
+     */
+    previousPage(): boolean;
+    /**
+     * Go to a specific page
+     */
+    goToPage(pageNumber: number): boolean;
+    /**
+     * Destroy and cleanup
+     */
+    destroy(): void;
+    private createPresentationContainer;
+    private destroyPresentationContainer;
+    private renderCurrentPage;
+    private notifyStateChange;
+    private enter;
+    private doExit;
+    private handleMouseWheel;
+    private normalizeWheelDelta;
+    private handleMouseDown;
+    private handleKeyDown;
+    private handleContextMenu;
+    private handleTouchSwipe;
+    private handleResize;
+    private resetMouseScrollState;
+    private addWindowListeners;
+    private removeWindowListeners;
+    private addFullscreenChangeListeners;
+    private removeFullscreenChangeListeners;
+}

package/dist/pdf-viewer/PdfPresentationMode.js

@@ -0,0 +1,437 @@
+/* Copyright 2024 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export var PresentationModeState;
+(function (PresentationModeState) {
+    PresentationModeState[PresentationModeState["UNKNOWN"] = 0] = "UNKNOWN";
+    PresentationModeState[PresentationModeState["NORMAL"] = 1] = "NORMAL";
+    PresentationModeState[PresentationModeState["CHANGING"] = 2] = "CHANGING";
+    PresentationModeState[PresentationModeState["FULLSCREEN"] = 3] = "FULLSCREEN";
+})(PresentationModeState || (PresentationModeState = {}));
+const MOUSE_SCROLL_COOLDOWN_TIME = 50; // in ms
+const PAGE_SWITCH_THRESHOLD = 0.1;
+const SWIPE_MIN_DISTANCE_THRESHOLD = 50;
+const SWIPE_ANGLE_THRESHOLD = Math.PI / 6;
+export class PdfPresentationMode {
+    state = PresentationModeState.UNKNOWN;
+    pdfDocument = null;
+    currentPageNumber = 1;
+    totalPages = 0;
+    container = null;
+    canvas = null;
+    callbacks;
+    fullscreenChangeAbortController = null;
+    windowAbortController = null;
+    mouseScrollTimeStamp = 0;
+    mouseScrollDelta = 0;
+    touchSwipeState = null;
+    renderingPage = false;
+    constructor(callbacks = {}) {
+        this.callbacks = callbacks;
+    }
+    /**
+     * Set the PDF document for presentation
+     */
+    setDocument(pdfDocument) {
+        this.pdfDocument = pdfDocument;
+        this.totalPages = pdfDocument?.numPages ?? 0;
+    }
+    /**
+     * Set the current page number (used when entering presentation mode)
+     */
+    setCurrentPage(pageNumber) {
+        this.currentPageNumber = Math.max(1, Math.min(pageNumber, this.totalPages));
+    }
+    /**
+     * Check if presentation mode is active
+     */
+    get active() {
+        return (this.state === PresentationModeState.CHANGING ||
+            this.state === PresentationModeState.FULLSCREEN);
+    }
+    /**
+     * Get current state
+     */
+    get currentState() {
+        return this.state;
+    }
+    /**
+     * Request entering fullscreen presentation mode
+     */
+    async request() {
+        if (this.active || !this.pdfDocument || this.totalPages === 0) {
+            return false;
+        }
+        // Create the presentation container
+        this.createPresentationContainer();
+        if (!this.container) {
+            return false;
+        }
+        this.addFullscreenChangeListeners();
+        this.notifyStateChange(PresentationModeState.CHANGING);
+        try {
+            await this.container.requestFullscreen();
+            return true;
+        }
+        catch {
+            this.removeFullscreenChangeListeners();
+            this.notifyStateChange(PresentationModeState.NORMAL);
+            this.destroyPresentationContainer();
+            return false;
+        }
+    }
+    /**
+     * Exit presentation mode
+     */
+    async exit() {
+        if (!this.active) {
+            return;
+        }
+        if (document.fullscreenElement) {
+            await document.exitFullscreen();
+        }
+    }
+    /**
+     * Go to next page
+     */
+    nextPage() {
+        if (this.currentPageNumber >= this.totalPages) {
+            return false;
+        }
+        this.currentPageNumber++;
+        this.renderCurrentPage();
+        this.callbacks.onPageChange?.(this.currentPageNumber);
+        return true;
+    }
+    /**
+     * Go to previous page
+     */
+    previousPage() {
+        if (this.currentPageNumber <= 1) {
+            return false;
+        }
+        this.currentPageNumber--;
+        this.renderCurrentPage();
+        this.callbacks.onPageChange?.(this.currentPageNumber);
+        return true;
+    }
+    /**
+     * Go to a specific page
+     */
+    goToPage(pageNumber) {
+        if (pageNumber < 1 || pageNumber > this.totalPages) {
+            return false;
+        }
+        this.currentPageNumber = pageNumber;
+        this.renderCurrentPage();
+        this.callbacks.onPageChange?.(this.currentPageNumber);
+        return true;
+    }
+    /**
+     * Destroy and cleanup
+     */
+    destroy() {
+        this.exit();
+        this.removeWindowListeners();
+        this.removeFullscreenChangeListeners();
+        this.destroyPresentationContainer();
+    }
+    // Private methods
+    createPresentationContainer() {
+        // Create fullscreen container
+        this.container = document.createElement('div');
+        this.container.className = 'pdf-presentation-mode';
+        this.container.style.cssText = `
+			position: fixed;
+			top: 0;
+			left: 0;
+			width: 100%;
+			height: 100%;
+			background-color: #000;
+			display: flex;
+			align-items: center;
+			justify-content: center;
+			z-index: 999999;
+		`;
+        // Create canvas for rendering
+        this.canvas = document.createElement('canvas');
+        this.canvas.style.cssText = `
+			max-width: 100%;
+			max-height: 100%;
+			object-fit: contain;
+		`;
+        this.container.appendChild(this.canvas);
+        document.body.appendChild(this.container);
+    }
+    destroyPresentationContainer() {
+        if (this.container) {
+            this.container.remove();
+            this.container = null;
+            this.canvas = null;
+        }
+    }
+    async renderCurrentPage() {
+        if (!this.pdfDocument || !this.canvas || !this.container || this.renderingPage) {
+            return;
+        }
+        this.renderingPage = true;
+        try {
+            const page = await this.pdfDocument.getPage(this.currentPageNumber);
+            // Calculate scale to fit the screen while maintaining aspect ratio
+            const containerWidth = window.innerWidth;
+            const containerHeight = window.innerHeight;
+            const viewport = page.getViewport({ scale: 1, rotation: 0 });
+            const pageWidth = viewport.width;
+            const pageHeight = viewport.height;
+            // Calculate scale to fit
+            const scaleX = containerWidth / pageWidth;
+            const scaleY = containerHeight / pageHeight;
+            const scale = Math.min(scaleX, scaleY);
+            const scaledViewport = page.getViewport({ scale, rotation: 0 });
+            // Set canvas size
+            this.canvas.width = scaledViewport.width;
+            this.canvas.height = scaledViewport.height;
+            const context = this.canvas.getContext('2d');
+            if (!context) {
+                return;
+            }
+            // Clear and render
+            context.fillStyle = '#fff';
+            context.fillRect(0, 0, this.canvas.width, this.canvas.height);
+            await page.render({
+                canvasContext: context,
+                viewport: scaledViewport,
+                canvas: this.canvas
+            }).promise;
+        }
+        catch (e) {
+            console.error('Failed to render presentation page:', e);
+        }
+        finally {
+            this.renderingPage = false;
+        }
+    }
+    notifyStateChange(newState) {
+        this.state = newState;
+        this.callbacks.onStateChange?.(newState);
+    }
+    enter() {
+        this.notifyStateChange(PresentationModeState.FULLSCREEN);
+        this.addWindowListeners();
+        this.renderCurrentPage();
+        // Clear any text selection
+        document.getSelection()?.empty();
+    }
+    doExit() {
+        this.removeWindowListeners();
+        this.destroyPresentationContainer();
+        this.resetMouseScrollState();
+        this.removeFullscreenChangeListeners();
+        this.notifyStateChange(PresentationModeState.NORMAL);
+    }
+    handleMouseWheel = (evt) => {
+        if (!this.active) {
+            return;
+        }
+        evt.preventDefault();
+        const delta = this.normalizeWheelDelta(evt);
+        const currentTime = Date.now();
+        const storedTime = this.mouseScrollTimeStamp;
+        // Cooldown to prevent accidental double-switching
+        if (currentTime > storedTime && currentTime - storedTime < MOUSE_SCROLL_COOLDOWN_TIME) {
+            return;
+        }
+        // Reset if direction changed
+        if ((this.mouseScrollDelta > 0 && delta < 0) || (this.mouseScrollDelta < 0 && delta > 0)) {
+            this.resetMouseScrollState();
+        }
+        this.mouseScrollDelta += delta;
+        if (Math.abs(this.mouseScrollDelta) >= PAGE_SWITCH_THRESHOLD) {
+            const totalDelta = this.mouseScrollDelta;
+            this.resetMouseScrollState();
+            const success = totalDelta > 0 ? this.previousPage() : this.nextPage();
+            if (success) {
+                this.mouseScrollTimeStamp = currentTime;
+            }
+        }
+    };
+    normalizeWheelDelta(evt) {
+        let delta = Math.hypot(evt.deltaX, evt.deltaY);
+        const angle = Math.atan2(evt.deltaY, evt.deltaX);
+        if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
+            delta = -delta;
+        }
+        if (evt.deltaMode === WheelEvent.DOM_DELTA_LINE) {
+            delta *= 30;
+        }
+        else if (evt.deltaMode === WheelEvent.DOM_DELTA_PAGE) {
+            delta *= 30 * 10;
+        }
+        return delta / 30;
+    }
+    handleMouseDown = (evt) => {
+        // Left click (0) = next page, Right click (2) = previous page
+        if (evt.button === 0) {
+            evt.preventDefault();
+            if (evt.shiftKey) {
+                this.previousPage();
+            }
+            else {
+                this.nextPage();
+            }
+        }
+        else if (evt.button === 2) {
+            evt.preventDefault();
+            this.previousPage();
+        }
+    };
+    handleKeyDown = (evt) => {
+        if (!this.active) {
+            return;
+        }
+        this.resetMouseScrollState();
+        switch (evt.key) {
+            case 'ArrowRight':
+            case 'ArrowDown':
+            case ' ':
+            case 'PageDown':
+            case 'Enter':
+                evt.preventDefault();
+                this.nextPage();
+                break;
+            case 'ArrowLeft':
+            case 'ArrowUp':
+            case 'PageUp':
+            case 'Backspace':
+                evt.preventDefault();
+                this.previousPage();
+                break;
+            case 'Home':
+                evt.preventDefault();
+                this.goToPage(1);
+                break;
+            case 'End':
+                evt.preventDefault();
+                this.goToPage(this.totalPages);
+                break;
+            case 'Escape':
+                // Escape is handled by the browser for fullscreen exit
+                break;
+        }
+    };
+    handleContextMenu = (evt) => {
+        // Prevent context menu - right-click is handled in handleMouseDown
+        evt.preventDefault();
+    };
+    handleTouchSwipe = (evt) => {
+        if (!this.active) {
+            return;
+        }
+        if (evt.touches.length > 1) {
+            this.touchSwipeState = null;
+            return;
+        }
+        switch (evt.type) {
+            case 'touchstart':
+                this.touchSwipeState = {
+                    startX: evt.touches[0].pageX,
+                    startY: evt.touches[0].pageY,
+                    endX: evt.touches[0].pageX,
+                    endY: evt.touches[0].pageY
+                };
+                break;
+            case 'touchmove':
+                if (this.touchSwipeState === null) {
+                    return;
+                }
+                this.touchSwipeState.endX = evt.touches[0].pageX;
+                this.touchSwipeState.endY = evt.touches[0].pageY;
+                evt.preventDefault();
+                break;
+            case 'touchend': {
+                if (this.touchSwipeState === null) {
+                    return;
+                }
+                const dx = this.touchSwipeState.endX - this.touchSwipeState.startX;
+                const dy = this.touchSwipeState.endY - this.touchSwipeState.startY;
+                const absAngle = Math.abs(Math.atan2(dy, dx));
+                let delta = 0;
+                if (Math.abs(dx) > SWIPE_MIN_DISTANCE_THRESHOLD &&
+                    (absAngle <= SWIPE_ANGLE_THRESHOLD || absAngle >= Math.PI - SWIPE_ANGLE_THRESHOLD)) {
+                    // Horizontal swipe
+                    delta = dx;
+                }
+                else if (Math.abs(dy) > SWIPE_MIN_DISTANCE_THRESHOLD &&
+                    Math.abs(absAngle - Math.PI / 2) <= SWIPE_ANGLE_THRESHOLD) {
+                    // Vertical swipe
+                    delta = dy;
+                }
+                if (delta > 0) {
+                    this.previousPage();
+                }
+                else if (delta < 0) {
+                    this.nextPage();
+                }
+                this.touchSwipeState = null;
+                break;
+            }
+        }
+    };
+    handleResize = () => {
+        if (this.active) {
+            this.renderCurrentPage();
+        }
+    };
+    resetMouseScrollState() {
+        this.mouseScrollTimeStamp = 0;
+        this.mouseScrollDelta = 0;
+    }
+    addWindowListeners() {
+        if (this.windowAbortController) {
+            return;
+        }
+        this.windowAbortController = new AbortController();
+        const { signal } = this.windowAbortController;
+        window.addEventListener('mousedown', this.handleMouseDown, { signal });
+        window.addEventListener('wheel', this.handleMouseWheel, { passive: false, signal });
+        window.addEventListener('keydown', this.handleKeyDown, { signal });
+        window.addEventListener('contextmenu', this.handleContextMenu, { signal });
+        window.addEventListener('touchstart', this.handleTouchSwipe, { signal });
+        window.addEventListener('touchmove', this.handleTouchSwipe, { passive: false, signal });
+        window.addEventListener('touchend', this.handleTouchSwipe, { signal });
+        window.addEventListener('resize', this.handleResize, { signal });
+    }
+    removeWindowListeners() {
+        this.windowAbortController?.abort();
+        this.windowAbortController = null;
+    }
+    addFullscreenChangeListeners() {
+        if (this.fullscreenChangeAbortController) {
+            return;
+        }
+        this.fullscreenChangeAbortController = new AbortController();
+        window.addEventListener('fullscreenchange', () => {
+            if (document.fullscreenElement) {
+                this.enter();
+            }
+            else {
+                this.doExit();
+            }
+        }, { signal: this.fullscreenChangeAbortController.signal });
+    }
+    removeFullscreenChangeListeners() {
+        this.fullscreenChangeAbortController?.abort();
+        this.fullscreenChangeAbortController = null;
+    }
+}

package/dist/pdf-viewer/context.d.ts

@@ -1,5 +1,12 @@
 /** PDF source - can be a URL string, ArrayBuffer, Uint8Array, or Blob */
 export type PdfSource = string | ArrayBuffer | Uint8Array | Blob;
+/** Presentation mode state */
+export declare enum PresentationModeState {
+    UNKNOWN = 0,
+    NORMAL = 1,
+    CHANGING = 2,
+    FULLSCREEN = 3
+}
 export interface PdfViewerState {
     loading: boolean;
     error: string | null;
@@ -11,6 +18,7 @@ export interface PdfViewerState {
     searchCurrent: number;
     searchTotal: number;
     isSearching: boolean;
+    presentationMode: PresentationModeState;
 }
 export interface PdfViewerActions {
     zoomIn: () => void;
@@ -24,6 +32,10 @@ export interface PdfViewerActions {
     searchPrevious: () => void;
     clearSearch: () => void;
     download: (filename?: string) => Promise<void>;
+    /** Enter fullscreen presentation mode */
+    enterPresentationMode: () => Promise<boolean>;
+    /** Exit fullscreen presentation mode */
+    exitPresentationMode: () => Promise<void>;
 }
 export interface PdfViewerContext {
     state: PdfViewerState;

package/dist/pdf-viewer/context.js

@@ -3,6 +3,14 @@
  */
 import { getContext, setContext } from 'svelte';
 const PDF_VIEWER_CONTEXT_KEY = Symbol('pdf-viewer');
+/** Presentation mode state */
+export var PresentationModeState;
+(function (PresentationModeState) {
+    PresentationModeState[PresentationModeState["UNKNOWN"] = 0] = "UNKNOWN";
+    PresentationModeState[PresentationModeState["NORMAL"] = 1] = "NORMAL";
+    PresentationModeState[PresentationModeState["CHANGING"] = 2] = "CHANGING";
+    PresentationModeState[PresentationModeState["FULLSCREEN"] = 3] = "FULLSCREEN";
+})(PresentationModeState || (PresentationModeState = {}));
 export function setPdfViewerContext(ctx) {
     setContext(PDF_VIEWER_CONTEXT_KEY, ctx);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-pdf-view",
-  "version": "0.1.13",
+  "version": "0.2.0",
   "description": "A modern, modular PDF viewer component for Svelte 5. Built on PDF.js with TypeScript support",
   "author": "Louis Li",
   "license": "Apache-2.0",