react-pdf-viewer-wasm 0.1.0

package/dist/components/Document.d.ts

@@ -0,0 +1,31 @@
+import { ReactNode } from 'react';
+interface DocContextValue {
+    docHandle: number;
+    scale: number;
+    rotate: number;
+}
+export declare function useDocContext(): DocContextValue;
+type FileInput = string | File | Uint8Array;
+interface DocumentProps {
+    file: FileInput;
+    className?: string | string[];
+    scale?: number;
+    rotate?: number;
+    error?: ReactNode | (() => ReactNode);
+    loading?: ReactNode | (() => ReactNode);
+    noData?: ReactNode | (() => ReactNode);
+    children?: ReactNode;
+    onLoadSuccess?: (info: {
+        numPages: number;
+    }) => void;
+    onLoadError?: (error: Error) => void;
+    onLoadProgress?: (info: {
+        loaded: number;
+        total: number;
+    }) => void;
+    onSourceSuccess?: () => void;
+    onSourceError?: (error: Error) => void;
+    onPassword?: (callback: (password: string) => void) => void;
+}
+export declare const Document: import('react').ForwardRefExoticComponent<DocumentProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/Page.d.ts

@@ -0,0 +1,8 @@
+interface PageProps {
+    pageIndex: number;
+    scale?: number;
+    rotate?: number;
+    textSelectable?: boolean;
+}
+export declare function Page({ pageIndex, scale, rotate, textSelectable }: PageProps): import("react").JSX.Element;
+export {};

package/dist/components/TextLayer.d.ts

@@ -0,0 +1,9 @@
+interface TextLayerProps {
+    docHandle: number;
+    pageIndex: number;
+    scale: number;
+    pageWidthPts: number;
+    pageHeightPts: number;
+}
+export declare function TextLayer({ docHandle, pageIndex, scale, pageWidthPts, pageHeightPts }: TextLayerProps): import("react").JSX.Element;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { Document } from './components/Document';
+export { Page } from './components/Page';
+export { setPdfiumSource } from './pdf-core/loadPdfEngine';

package/dist/index.mjs

@@ -0,0 +1,662 @@
+import { createContext as e, forwardRef as t, useContext as n, useEffect as r, useImperativeHandle as i, useRef as a, useState as o } from "react";
+import { jsx as s, jsxs as c } from "react/jsx-runtime";
+//#region \0rolldown/runtime.js
+var l = Object.defineProperty, u = /* @__PURE__ */ ((e, t) => {
+	let n = {};
+	for (var r in e) l(n, r, {
+		get: e[r],
+		enumerable: !0
+	});
+	return t || l(n, Symbol.toStringTag, { value: "Module" }), n;
+})({
+	close_document: () => d,
+	default: () => J,
+	extract_text: () => f,
+	get_page_count: () => p,
+	get_page_dimensions: () => m,
+	get_text_chars: () => h,
+	initSync: () => re,
+	initialize: () => g,
+	initialize_pdfium_render: () => _,
+	open_document: () => v,
+	read_block_from_callback_wasm: () => y,
+	render_page: () => b,
+	start: () => x,
+	write_block_from_callback_wasm: () => S
+});
+function d(e) {
+	let t = G.close_document(e);
+	if (t[1]) throw R(t[0]);
+}
+function f(e, t) {
+	let n = G.extract_text(e, t);
+	if (n[3]) throw R(n[2]);
+	var r = D(n[0], n[1]);
+	return n[0] !== 0 && G.__wbindgen_free(n[0], n[1], 1), r;
+}
+function p(e) {
+	let t = G.get_page_count(e);
+	if (t[2]) throw R(t[1]);
+	return t[0] >>> 0;
+}
+function m(e, t) {
+	let n = G.get_page_dimensions(e, t);
+	if (n[3]) throw R(n[2]);
+	var r = ee(n[0], n[1]).slice();
+	return G.__wbindgen_free(n[0], n[1] * 4, 4), r;
+}
+function h(e, t) {
+	let n = G.get_text_chars(e, t);
+	if (n[3]) throw R(n[2]);
+	var r = D(n[0], n[1]);
+	return n[0] !== 0 && G.__wbindgen_free(n[0], n[1], 1), r;
+}
+function g() {
+	let e = G.initialize();
+	if (e[1]) throw R(e[0]);
+}
+function _(e, t, n) {
+	return G.initialize_pdfium_render(e, t, n) !== 0;
+}
+function v(e, t) {
+	let n = I(e, G.__wbindgen_malloc), r = W;
+	var i = F(t) ? 0 : L(t, G.__wbindgen_malloc, G.__wbindgen_realloc), a = W;
+	let o = G.open_document(n, r, i, a);
+	if (o[2]) throw R(o[1]);
+	return o[0] >>> 0;
+}
+function y(e, t, n, r) {
+	return G.read_block_from_callback_wasm(e, t, n, r);
+}
+function b(e, t, n, r) {
+	let i = G.render_page(e, t, n, r);
+	if (i[2]) throw R(i[1]);
+	return R(i[0]);
+}
+function x() {
+	G.start();
+}
+function S(e, t, n) {
+	return G.write_block_from_callback_wasm(e, t, n);
+}
+function C() {
+	return {
+		__proto__: null,
+		"./pdf_core_bg.js": {
+			__proto__: null,
+			__wbg___wbindgen_debug_string_0e68cf47c9cbd9b0: function(e, t) {
+				let n = L(T(t), G.__wbindgen_malloc, G.__wbindgen_realloc), r = W;
+				k().setInt32(e + 4, r, !0), k().setInt32(e + 0, n, !0);
+			},
+			__wbg___wbindgen_is_object_edb6b15aa3afe12e: function(e) {
+				let t = e;
+				return typeof t == "object" && !!t;
+			},
+			__wbg___wbindgen_is_undefined_8c687d0b90d5b524: function(e) {
+				return e === void 0;
+			},
+			__wbg___wbindgen_jsval_eq_9fdcd3c0a860dd3b: function(e, t) {
+				return e === t;
+			},
+			__wbg___wbindgen_number_get_1dc732b810cb937c: function(e, t) {
+				let n = t, r = typeof n == "number" ? n : void 0;
+				k().setFloat64(e + 8, F(r) ? 0 : r, !0), k().setInt32(e + 0, !F(r), !0);
+			},
+			__wbg___wbindgen_string_get_92ab86bb19cbc12f: function(e, t) {
+				let n = t, r = typeof n == "string" ? n : void 0;
+				var i = F(r) ? 0 : L(r, G.__wbindgen_malloc, G.__wbindgen_realloc), a = W;
+				k().setInt32(e + 4, a, !0), k().setInt32(e + 0, i, !0);
+			},
+			__wbg___wbindgen_throw_5d9e815e6fdf150f: function(e, t) {
+				var n = D(e, t);
+				throw Error(n);
+			},
+			__wbg_apply_5d9aa7604c2490a8: function() {
+				return P(function(e, t, n) {
+					return e.apply(t, n);
+				}, arguments);
+			},
+			__wbg_call_6bcf8d3e20937e46: function() {
+				return P(function(e, t, n) {
+					return e.call(t, n);
+				}, arguments);
+			},
+			__wbg_debug_eb092a10b3338acb: function(e) {
+				console.debug(e);
+			},
+			__wbg_decode_ec8279b49e2f79cf: function() {
+				return P(function(e, t, n, r) {
+					let i = L(t.decode(E(n, r)), G.__wbindgen_malloc, G.__wbindgen_realloc), a = W;
+					k().setInt32(e + 4, a, !0), k().setInt32(e + 0, i, !0);
+				}, arguments);
+			},
+			__wbg_error_756c5934221e6fee: function(e) {
+				console.error(e);
+			},
+			__wbg_error_757e9472f8410341: function(e, t) {
+				var n = D(e, t);
+				e !== 0 && G.__wbindgen_free(e, t, 1), console.error(n);
+			},
+			__wbg_from_a39669ce566077da: function(e) {
+				return Array.from(e);
+			},
+			__wbg_getTime_65922ba0b59d55a7: function(e) {
+				return e.getTime();
+			},
+			__wbg_get_97dc2df9d87d0f6a: function() {
+				return P(function(e, t) {
+					return e.get(t >>> 0);
+				}, arguments);
+			},
+			__wbg_get_989d0a1309644f2b: function() {
+				return P(function(e, t) {
+					return Reflect.get(e, t);
+				}, arguments);
+			},
+			__wbg_get_index_a916f0ff97f6772a: function(e, t) {
+				return e[t >>> 0];
+			},
+			__wbg_get_unchecked_363572bdd397d473: function(e, t) {
+				return e[t >>> 0];
+			},
+			__wbg_info_f25c01bee103395d: function(e) {
+				console.info(e);
+			},
+			__wbg_isArray_5674713bb7b79043: function(e) {
+				return Array.isArray(e);
+			},
+			__wbg_length_31bdaf014f5fbde2: function(e) {
+				return e.length;
+			},
+			__wbg_length_4e1adc0d42e23620: function(e) {
+				return e.length;
+			},
+			__wbg_length_e1c40798f58a4170: function(e) {
+				return e.length;
+			},
+			__wbg_length_e87c15f832faddc2: function(e) {
+				return e.length;
+			},
+			__wbg_log_363d83b9114c8831: function(e) {
+				console.log(e);
+			},
+			__wbg_new_0_35540e542ba689d2: function() {
+				return /* @__PURE__ */ new Date();
+			},
+			__wbg_new_227d7c05414eb861: function() {
+				return /* @__PURE__ */ Error();
+			},
+			__wbg_new_ffa92086ea89f79c: function() {
+				return [];
+			},
+			__wbg_new_from_slice_4ee02165f9de919e: function(e, t) {
+				return new Uint8Array(E(e, t));
+			},
+			__wbg_new_with_label_aad02dde1eb03f9b: function() {
+				return P(function(e, t) {
+					var n = D(e, t);
+					return new TextDecoder(n);
+				}, arguments);
+			},
+			__wbg_new_with_length_6a9fc3631737ef8c: function(e) {
+				return Array(e >>> 0);
+			},
+			__wbg_of_04ed67a73000e0bd: function(e, t, n, r) {
+				return [
+					e,
+					t,
+					n,
+					r
+				];
+			},
+			__wbg_of_1a3f47170341cefe: function(e) {
+				return [e];
+			},
+			__wbg_of_1c173c2ad96e2f7e: function(e, t) {
+				return [e, t];
+			},
+			__wbg_of_8211d46fcab1ec90: function(e, t, n, r, i) {
+				return [
+					e,
+					t,
+					n,
+					r,
+					i
+				];
+			},
+			__wbg_of_d9a05aa72bb023a2: function(e, t, n) {
+				return [
+					e,
+					t,
+					n
+				];
+			},
+			__wbg_prototypesetcall_ae9f5e7459250748: function(e, t, n) {
+				Uint8Array.prototype.set.call(E(e, t), n);
+			},
+			__wbg_push_bfdf956ba476f65b: function(e, t) {
+				return e.push(t);
+			},
+			__wbg_set_13d25b81ab403f5e: function(e, t, n) {
+				e[t >>> 0] = n;
+			},
+			__wbg_set_361ed22a3b8802e9: function() {
+				return P(function(e, t, n) {
+					e.set(t >>> 0, n);
+				}, arguments);
+			},
+			__wbg_set_9cfc0f17d60ff0af: function(e, t, n) {
+				e.set(t, n >>> 0);
+			},
+			__wbg_slice_ec88db741786524b: function(e, t, n) {
+				return e.slice(t >>> 0, n >>> 0);
+			},
+			__wbg_stack_3b0d974bbf31e44f: function(e, t) {
+				let n = t.stack, r = L(n, G.__wbindgen_malloc, G.__wbindgen_realloc), i = W;
+				k().setInt32(e + 4, i, !0), k().setInt32(e + 0, r, !0);
+			},
+			__wbg_static_accessor_GLOBAL_8eb4cd83130a11a0: function() {
+				let e = typeof global > "u" ? null : global;
+				return F(e) ? 0 : w(e);
+			},
+			__wbg_static_accessor_GLOBAL_THIS_1e7044f654e934db: function() {
+				let e = typeof globalThis > "u" ? null : globalThis;
+				return F(e) ? 0 : w(e);
+			},
+			__wbg_static_accessor_SELF_d8b50611246a6d92: function() {
+				let e = typeof self > "u" ? null : self;
+				return F(e) ? 0 : w(e);
+			},
+			__wbg_static_accessor_WINDOW_fd0bc376bf0f8b42: function() {
+				let e = typeof window > "u" ? null : window;
+				return F(e) ? 0 : w(e);
+			},
+			__wbg_subarray_1daff70dde20c145: function(e, t, n) {
+				return e.subarray(t >>> 0, n >>> 0);
+			},
+			__wbg_warn_d3544c7814fab534: function(e) {
+				console.warn(e);
+			},
+			__wbindgen_generic_0000000000000001: function(e) {
+				return e;
+			},
+			__wbindgen_generic_0000000000000002: function(e, t) {
+				return D(e, t);
+			},
+			__wbindgen_generic_0000000000000003: function(e, t) {
+				return E(e, t);
+			},
+			__wbindgen_init_externref_table: function() {
+				let e = G.__wbindgen_externrefs, t = e.grow(4);
+				e.set(0, void 0), e.set(t + 0, void 0), e.set(t + 1, null), e.set(t + 2, !0), e.set(t + 3, !1);
+			}
+		}
+	};
+}
+function w(e) {
+	let t = G.__externref_table_alloc();
+	return G.__wbindgen_externrefs.set(t, e), t;
+}
+function T(e) {
+	let t = typeof e;
+	if (t == "number" || t == "boolean" || e == null) return `${e}`;
+	if (t == "string") return `"${e}"`;
+	if (t == "symbol") {
+		let t = e.description;
+		return t == null ? "Symbol" : `Symbol(${t})`;
+	}
+	if (t == "function") {
+		let t = e.name;
+		return typeof t == "string" && t.length > 0 ? `Function(${t})` : "Function";
+	}
+	if (Array.isArray(e)) {
+		let t = e.length, n = "[";
+		t > 0 && (n += T(e[0]));
+		for (let r = 1; r < t; r++) n += ", " + T(e[r]);
+		return n += "]", n;
+	}
+	let n = /\[object ([^\]]+)\]/.exec(toString.call(e)), r;
+	if (n && n.length > 1) r = n[1];
+	else return toString.call(e);
+	if (r == "Object") try {
+		return "Object(" + JSON.stringify(e) + ")";
+	} catch {
+		return "Object";
+	}
+	return e instanceof Error ? `${e.name}: ${e.message}\n${e.stack}` : r;
+}
+function ee(e, t) {
+	return e >>>= 0, j().subarray(e / 4, e / 4 + t);
+}
+function E(e, t) {
+	return e >>>= 0, N().subarray(e / 1, e / 1 + t);
+}
+function D(e, t) {
+	return e === 0 ? te(t) : ne(e, t);
+}
+var O = null;
+function k() {
+	return (O === null || O.buffer.detached === !0 || O.buffer.detached === void 0 && O.buffer !== G.memory.buffer) && (O = new DataView(G.memory.buffer)), O;
+}
+var A = null;
+function j() {
+	return (A === null || A.byteLength === 0) && (A = new Float32Array(G.memory.buffer)), A;
+}
+function te(e) {
+	return G.__wbindgen_externrefs.get(e);
+}
+function ne(e, t) {
+	return H(e >>> 0, t);
+}
+var M = null;
+function N() {
+	return (M === null || M.byteLength === 0) && (M = new Uint8Array(G.memory.buffer)), M;
+}
+function P(e, t) {
+	try {
+		return e.apply(this, t);
+	} catch (e) {
+		let t = w(e);
+		G.__wbindgen_exn_store(t);
+	}
+}
+function F(e) {
+	return e == null;
+}
+function I(e, t) {
+	let n = t(e.length * 1, 1) >>> 0;
+	return N().set(e, n / 1), W = e.length, n;
+}
+function L(e, t, n) {
+	if (n === void 0) {
+		let n = U.encode(e), r = t(n.length, 1) >>> 0;
+		return N().subarray(r, r + n.length).set(n), W = n.length, r;
+	}
+	let r = e.length, i = t(r, 1) >>> 0, a = N(), o = 0;
+	for (; o < r; o++) {
+		let t = e.charCodeAt(o);
+		if (t > 127) break;
+		a[i + o] = t;
+	}
+	if (o !== r) {
+		o !== 0 && (e = e.slice(o)), i = n(i, r, r = o + e.length * 3, 1) >>> 0;
+		let t = N().subarray(i + o, i + r), a = U.encodeInto(e, t);
+		o += a.written, i = n(i, r, o, 1) >>> 0;
+	}
+	return W = o, i;
+}
+function R(e) {
+	let t = G.__wbindgen_externrefs.get(e);
+	return G.__externref_table_dealloc(e), t;
+}
+var z = new TextDecoder("utf-8", {
+	ignoreBOM: !0,
+	fatal: !0
+});
+z.decode();
+var B = 2146435072, V = 0;
+function H(e, t) {
+	return V += t, V >= B && (z = new TextDecoder("utf-8", {
+		ignoreBOM: !0,
+		fatal: !0
+	}), z.decode(), V = t), z.decode(N().subarray(e, e + t));
+}
+var U = new TextEncoder();
+"encodeInto" in U || (U.encodeInto = function(e, t) {
+	let n = U.encode(e);
+	return t.set(n), {
+		read: e.length,
+		written: n.length
+	};
+});
+var W = 0, G;
+function K(e, t) {
+	return G = e.exports, O = null, A = null, M = null, G.__wbindgen_start(), G;
+}
+async function q(e, t) {
+	if (typeof Response == "function" && e instanceof Response) {
+		if (!e.ok) throw Error(`failed to fetch Wasm: ${e.status} ${e.statusText} fetching '${e.url}'`);
+		if (typeof WebAssembly.instantiateStreaming == "function") try {
+			return await WebAssembly.instantiateStreaming(e, t);
+		} catch (t) {
+			if (n(e.type) && e.headers.get("Content-Type") !== "application/wasm") console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", t);
+			else throw t;
+		}
+		let r = await e.arrayBuffer();
+		return await WebAssembly.instantiate(r, t);
+	}
+	{
+		let n = await WebAssembly.instantiate(e, t);
+		return n instanceof WebAssembly.Instance ? {
+			instance: n,
+			module: e
+		} : n;
+	}
+	function n(e) {
+		switch (e) {
+			case "basic":
+			case "cors":
+			case "default": return !0;
+		}
+		return !1;
+	}
+}
+function re(e) {
+	if (G !== void 0) return G;
+	e !== void 0 && (Object.getPrototypeOf(e) === Object.prototype ? {module: e} = e : console.warn("using deprecated parameters for `initSync()`; pass a single object instead"));
+	let t = C();
+	return e instanceof WebAssembly.Module || (e = new WebAssembly.Module(e)), K(new WebAssembly.Instance(e, t), e);
+}
+async function J(e) {
+	if (G !== void 0) return G;
+	e !== void 0 && (Object.getPrototypeOf(e) === Object.prototype ? {module_or_path: e} = e : console.warn("using deprecated parameters for the initialization function; pass a single object instead")), e === void 0 && (e = new URL("/pdf_core_bg.wasm", "" + import.meta.url));
+	let t = C();
+	(typeof e == "string" || typeof Request == "function" && e instanceof Request || typeof URL == "function" && e instanceof URL) && (e = fetch(e));
+	let { instance: n, module: r } = await q(await e, t);
+	return K(n, r);
+}
+//#endregion
+//#region src/pdf-core/loadPdfEngine.ts
+var ie = "https://cdn.jsdelivr.net/npm/pdf-viewer-assets@1.0.0/pdfium.js", ae = "https://cdn.jsdelivr.net/npm/pdf-viewer-assets@1.0.0/pdfium.wasm", Y = ie, X = ae, Z = null;
+function oe(e) {
+	if (Z) throw Error("setPdfiumSource() must be called before the first <Document> is rendered. The pdfium engine has already started loading.");
+	Y = e.jsUrl, X = e.wasmUrl;
+}
+function se(e) {
+	return new Promise((t, n) => {
+		if (document.querySelector(`script[src="${e}"]`)) {
+			t();
+			return;
+		}
+		let r = document.createElement("script");
+		r.src = e, r.onload = () => t(), r.onerror = () => n(/* @__PURE__ */ Error(`Failed to load script: ${e}`)), document.head.appendChild(r);
+	});
+}
+function Q() {
+	return Z || (Z = (async () => {
+		await se(Y);
+		let e = await window.PDFiumModule({ locateFile: () => X });
+		if (await J(), !_(e, u, !1)) throw Error("Failed to initialize pdfium-render");
+		return g(), u;
+	})(), Z);
+}
+//#endregion
+//#region src/components/Document.tsx
+var $ = e(null);
+function ce() {
+	let e = n($);
+	if (!e) throw Error("Page must be used inside a Document");
+	return e;
+}
+async function le(e, t) {
+	if (e instanceof Uint8Array) return e;
+	if (e instanceof File) return new Uint8Array(await e.arrayBuffer());
+	let n = await fetch(e);
+	if (!n.ok) throw Error(`Failed to fetch PDF: ${n.status}`);
+	let r = Number(n.headers.get("content-length")) || 0;
+	if (!n.body || !r) return new Uint8Array(await n.arrayBuffer());
+	let i = n.body.getReader(), a = [], o = 0;
+	for (;;) {
+		let { done: e, value: n } = await i.read();
+		if (e) break;
+		a.push(n), o += n.length, t?.(o, r);
+	}
+	let s = new Uint8Array(o), c = 0;
+	for (let e of a) s.set(e, c), c += e.length;
+	return s;
+}
+var ue = t(function({ file: e, className: t, scale: n = 1, rotate: c = 0, error: l = "Failed to load PDF file.", loading: u = "Loading PDF…", noData: d = "No PDF file specified.", children: f, onLoadSuccess: p, onLoadError: m, onLoadProgress: h, onSourceSuccess: g, onSourceError: _, onPassword: v }, y) {
+	let [b, x] = o(null), [S, C] = o("loading"), w = a(null);
+	i(y, () => w.current), r(() => {
+		if (!e) {
+			C("idle");
+			return;
+		}
+		let t = !1;
+		return C("loading"), (async () => {
+			try {
+				let n = await Q(), r = await le(e, (e, t) => {
+					h?.({
+						loaded: e,
+						total: t
+					});
+				});
+				if (t) return;
+				g?.();
+				let i;
+				try {
+					i = n.open_document(r, void 0);
+				} catch (e) {
+					let t = String(e);
+					if (t.includes("Password") || t.includes("password")) {
+						if (!v) throw Error("Password-protected PDF, but no onPassword handler provided.");
+						i = await new Promise((e, t) => {
+							v((i) => {
+								try {
+									e(n.open_document(r, i));
+								} catch (e) {
+									t(e);
+								}
+							});
+						});
+					} else throw e;
+				}
+				if (t) return;
+				x(i), C("idle"), p?.({ numPages: n.get_page_count(i) });
+			} catch (e) {
+				if (t) return;
+				C("error");
+				let n = e instanceof Error ? e : Error(String(e));
+				m?.(n), _?.(n);
+			}
+		})(), () => {
+			t = !0;
+		};
+	}, [e]);
+	let T = ["react-pdf-viewer-wasm__Document", Array.isArray(t) ? t.join(" ") : t].filter(Boolean).join(" ");
+	return e ? S === "loading" ? /* @__PURE__ */ s("div", {
+		className: T,
+		ref: w,
+		children: typeof u == "function" ? u() : u
+	}) : S === "error" || b === null ? /* @__PURE__ */ s("div", {
+		className: T,
+		ref: w,
+		children: typeof l == "function" ? l() : l
+	}) : /* @__PURE__ */ s("div", {
+		className: T,
+		ref: w,
+		children: /* @__PURE__ */ s($.Provider, {
+			value: {
+				docHandle: b,
+				scale: n,
+				rotate: c
+			},
+			children: f
+		})
+	}) : /* @__PURE__ */ s("div", {
+		className: T,
+		ref: w,
+		children: typeof d == "function" ? d() : d
+	});
+});
+//#endregion
+//#region src/components/TextLayer.tsx
+function de({ docHandle: e, pageIndex: t, scale: n, pageWidthPts: i, pageHeightPts: a }) {
+	let [c, l] = o([]);
+	return r(() => {
+		let n = !1;
+		return (async () => {
+			let r = (await Q()).get_text_chars(e, t);
+			n || l(JSON.parse(r));
+		})(), () => {
+			n = !0;
+		};
+	}, [e, t]), /* @__PURE__ */ s("div", {
+		"data-pdf-textlayer": "true",
+		style: {
+			position: "absolute",
+			top: 0,
+			left: 0,
+			width: i * n,
+			height: a * n,
+			pointerEvents: "none"
+		},
+		children: c.map((e, t) => /* @__PURE__ */ s("span", {
+			style: {
+				position: "absolute",
+				left: e.left * n,
+				top: e.top * n,
+				width: e.width * n,
+				height: e.height * n,
+				fontSize: e.height * n,
+				lineHeight: 1,
+				color: "transparent",
+				whiteSpace: "pre",
+				userSelect: "text",
+				pointerEvents: "auto"
+			},
+			children: e.ch
+		}, t))
+	});
+}
+//#endregion
+//#region src/components/Page.tsx
+function fe({ pageIndex: e, scale: t, rotate: n, textSelectable: i = !0 }) {
+	let l = ce(), u = t ?? l.scale, d = n ?? l.rotate, f = a(null), [p, m] = o(null);
+	return r(() => {
+		let t = !1;
+		return (async () => {
+			let n = await Q(), [r, i] = n.get_page_dimensions(l.docHandle, e), a = d === 90 || d === 270, o = a ? i : r, s = a ? r : i, c = Math.round(o * u), p = Math.round(s * u), h = n.render_page(l.docHandle, e, u, d);
+			if (t || !f.current) return;
+			let g = f.current;
+			g.width = c, g.height = p, g.getContext("2d").putImageData(new ImageData(new Uint8ClampedArray(h), c, p), 0, 0), m({
+				w: o,
+				h: s
+			});
+		})(), () => {
+			t = !0;
+		};
+	}, [
+		l.docHandle,
+		e,
+		u,
+		d
+	]), /* @__PURE__ */ c("div", {
+		style: {
+			position: "relative",
+			display: "inline-block"
+		},
+		children: [/* @__PURE__ */ s("canvas", {
+			ref: f,
+			style: { display: "block" }
+		}), i && p && /* @__PURE__ */ s(de, {
+			docHandle: l.docHandle,
+			pageIndex: e,
+			scale: u,
+			pageWidthPts: p.w,
+			pageHeightPts: p.h
+		})]
+	});
+}
+//#endregion
+export { ue as Document, fe as Page, oe as setPdfiumSource };

package/dist/pdf-core/loadPdfEngine.d.ts

@@ -0,0 +1,18 @@
+import * as PdfCore from './pdf_core.js';
+/**
+ * Override where the pdfium engine (pdfium.js / pdfium.wasm) is loaded from.
+ * Call this BEFORE rendering any <Document>, if you need to self-host these
+ * files instead of using the default CDN (e.g. for corporate networks that
+ * block external CDNs, offline/airgapped apps, or strict CSP policies).
+ *
+ * Example:
+ *   setPdfiumSource({
+ *     jsUrl: '/vendor/pdfium.js',
+ *     wasmUrl: '/vendor/pdfium.wasm',
+ *   });
+ */
+export declare function setPdfiumSource(options: {
+    jsUrl: string;
+    wasmUrl: string;
+}): void;
+export declare function loadPdfEngine(): Promise<typeof PdfCore>;

package/dist/pdf-core/pdf_core.d.ts

@@ -0,0 +1,166 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Free a document from memory.
+ *
+ * Drops both the raw bytes and the cached metadata.
+ * After this call, using the handle in any other function returns an error.
+ */
+export function close_document(doc_handle: number): void;
+
+/**
+ * Extract all text from a specific page.
+ *
+ * Returns an empty string if the page contains no selectable text
+ * (e.g., scanned images without OCR).
+ *
+ * KNOWN LIMITATION: re-parses the PDF from bytes on every call.
+ * Same root cause as `render_page`; see that function's doc comment for
+ * the planned fix (`ouroboros` / `self_cell` self-referential struct).
+ */
+export function extract_text(doc_handle: number, page_index: number): string;
+
+/**
+ * Returns the total number of pages in the document.
+ *
+ * O(1) — served from the metadata cache built at `open_document` time.
+ * Does **not** re-parse the PDF.
+ */
+export function get_page_count(doc_handle: number): number;
+
+/**
+ * Returns `[width_pts, height_pts]` for the given page.
+ *
+ * Dimensions are in **PDF points** (72 points = 1 inch).
+ * Multiply by your `scale` factor to get pixel dimensions.
+ *
+ * O(1) — served from the metadata cache built at `open_document` time.
+ * Does **not** re-parse the PDF.
+ */
+export function get_page_dimensions(doc_handle: number, page_index: number): Float32Array;
+
+/**
+ * Returns per-character position data for a page, as a JSON string.
+ * Coordinates are in PDF points, with origin at TOP-LEFT (converted from
+ * pdfium's native bottom-left origin) so they map directly onto a
+ * top-left-origin HTML/CSS layer once multiplied by your zoom scale.
+ */
+export function get_text_chars(doc_handle: number, page_index: number): string;
+
+/**
+ * Initialize the pdfium binding.
+ *
+ * **Must be called once before any other function.**
+ * Calling it multiple times is safe — subsequent calls are no-ops.
+ *
+ * On native (cargo test): links against the system pdfium shared library.
+ * On WASM:               connects to the pdfium.wasm module loaded by the JS host.
+ */
+export function initialize(): void;
+
+/**
+ * Establishes a binding between an external Pdfium WASM module and `pdfium-render`'s WASM module.
+ * This function should be called from Javascript once the external Pdfium WASM module has been loaded
+ * into the browser. It is essential that this function is called _before_ initializing
+ * `pdfium-render` from within Rust code. For an example, see:
+ * <https://github.com/ajrcarey/pdfium-render/blob/master/examples/index.html>
+ */
+export function initialize_pdfium_render(pdfium_wasm_module: any, local_wasm_module: any, debug: boolean): boolean;
+
+/**
+ * Load a PDF from raw bytes.
+ *
+ * Returns a **document handle** (u32) that identifies this document in all
+ * subsequent calls.  Call `close_document()` when done to free memory.
+ *
+ * This is the **only** time the full PDF is parsed to extract metadata.
+ * Page count and page dimensions are cached here so subsequent calls to
+ * `get_page_count` and `get_page_dimensions` are O(1) and never re-parse.
+ *
+ * Errors if the bytes are not a valid PDF.
+ */
+export function open_document(bytes: Uint8Array, password?: string | null): number;
+
+/**
+ * A callback function that can be invoked by Pdfium's `FPDF_LoadCustomDocument()` function,
+ * wrapping around `crate::utils::files::read_block_from_callback()` to shuffle data buffers
+ * from our WASM memory heap to Pdfium's WASM memory heap as they are loaded.
+ */
+export function read_block_from_callback_wasm(param: number, position: number, pBuf: number, size: number): number;
+
+/**
+ * Render a single page to raw **RGBA pixel data**.
+ *
+ * - `scale = 1.0` → 72 DPI (native PDF point resolution)
+ * - `scale = 1.5` → 108 DPI
+ * - `scale = 2.0` → 144 DPI (retina-quality)
+ *
+ * Returns a flat `Uint8Array` of `[R, G, B, A, R, G, B, A, …]` bytes.
+ * The output pixel dimensions are `round(width_pts * scale) × round(height_pts * scale)`.
+ *
+ * Call `get_page_dimensions()` beforehand to know the canvas size (O(1), no re-parse).
+ *
+ * KNOWN LIMITATION: re-parses the PDF from bytes on every call.
+ * For a user scrolling through a 200-page document this means 200 re-parses.
+ * Future fix: use `ouroboros` or `self_cell` to store a parsed `PdfDocument`
+ * alongside the bytes it borrows from, eliminating the re-parse entirely.
+ */
+export function render_page(doc_handle: number, page_index: number, scale: number, rotation_degrees: number): Uint8Array;
+
+export function start(): void;
+
+/**
+ * A callback function that can be invoked by Pdfium's `FPDF_SaveAsCopy()` and `FPDF_SaveWithVersion()`
+ * functions, wrapping around `crate::utils::files::write_block_from_callback()` to shuffle data buffers
+ * from Pdfium's WASM memory heap to our WASM memory heap as they are written.
+ */
+export function write_block_from_callback_wasm(param: number, buf: number, size: number): number;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly close_document: (a: number) => [number, number];
+    readonly extract_text: (a: number, b: number) => [number, number, number, number];
+    readonly get_page_count: (a: number) => [number, number, number];
+    readonly get_page_dimensions: (a: number, b: number) => [number, number, number, number];
+    readonly get_text_chars: (a: number, b: number) => [number, number, number, number];
+    readonly initialize: () => [number, number];
+    readonly initialize_pdfium_render: (a: any, b: any, c: number) => number;
+    readonly open_document: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly read_block_from_callback_wasm: (a: number, b: number, c: number, d: number) => number;
+    readonly render_page: (a: number, b: number, c: number, d: number) => [number, number, number];
+    readonly start: () => void;
+    readonly write_block_from_callback_wasm: (a: number, b: number, c: number) => number;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __externref_table_dealloc: (a: number) => void;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "react-pdf-viewer-wasm",
+  "version": "0.1.0",
+  "description": "A React PDF viewer powered by Rust + WebAssembly, using pdfium as the rendering backend.",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "peerDependencies": {
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "vite build"
+  },
+  "license": "MIT",
+  "author": "Rohit Kumar <shan.rohitkumar12@gmail.com>",
+  "keywords": [
+    "pdf",
+    "react",
+    "wasm",
+    "rust",
+    "pdfium",
+    "viewer",
+    "render-pdf"
+  ],
+  "devDependencies": {
+    "@types/react": "^19.3.0",
+    "@types/react-dom": "^19.3.0",
+    "@typescript/typescript6": "^6.0.2",
+    "@vitejs/plugin-react": "^6.1.1",
+    "react": "^19.3.0",
+    "react-dom": "^19.3.0",
+    "typescript": "^7.0.2",
+    "vite": "^8.3.0",
+    "vite-plugin-dts": "^5.1.0"
+  }
+}

package/readme.md

@@ -0,0 +1,256 @@
+# react-pdf-viewer-wasm
+
+Show PDF files in your React app — powered by **Rust + WebAssembly** instead of the usual `pdf.js`.
+
+This library uses **pdfium**, the same PDF engine built into Google Chrome, to draw PDF pages onto the screen. It works a lot like the popular `react-pdf` package, but under the hood it's a completely different engine.
+
+> **Status:** early release (v0.1.x). The basics — viewing pages, zooming, rotating, selecting text, password-protected files — all work. Some more advanced features (clickable links, bookmarks, forms) aren't built yet. See [What's not supported yet](#whats-not-supported-yet).
+
+---
+
+## What you get
+
+- 📄 Render any PDF page onto the screen
+- 🔍 Zoom in and out
+- 🔄 Rotate pages
+- ✍️ Select and copy text from the PDF (just like a real document)
+- 🔒 Support for password-protected PDFs
+- ⚡ No setup needed — the PDF engine loads automatically from the internet the first time it's used
+
+---
+
+## Installing it
+
+```bash
+npm install react-pdf-viewer-wasm
+```
+
+That's it. You don't need to download or configure anything else — this library automatically fetches the small "PDF engine" file it needs from the internet the first time your app shows a PDF.
+
+*(If your company's network blocks outside websites, see [Using it without the internet](#using-it-without-the-internet) below.)*
+
+---
+
+## Showing your first PDF
+
+```tsx
+import { Document, Page } from 'react-pdf-viewer-wasm';
+
+function App() {
+  return (
+    <Document file="/my-file.pdf">
+      <Page pageIndex={0} />
+    </Document>
+  );
+}
+```
+
+That's the whole thing. `pageIndex={0}` means "show the first page" (pages are counted starting from 0, not 1).
+
+Put your PDF file in your app's `public` folder so `"/my-file.pdf"` can find it. You can also use a full web address instead, like `"https://example.com/my-file.pdf"`.
+
+---
+
+## Showing every page in the PDF
+
+```tsx
+import { useState } from 'react';
+import { Document, Page } from 'react-pdf-viewer-wasm';
+
+function App() {
+  const [numPages, setNumPages] = useState(0);
+
+  return (
+    <Document
+      file="/my-file.pdf"
+      onLoadSuccess={({ numPages }) => setNumPages(numPages)}
+    >
+      {Array.from({ length: numPages }, (_, i) => (
+        <Page key={i} pageIndex={i} />
+      ))}
+    </Document>
+  );
+}
+```
+
+`onLoadSuccess` tells you how many pages the PDF has, once it's finished loading. We use that number to draw one `<Page>` for every page in the file.
+
+---
+
+## Zooming in and out
+
+```tsx
+<Document file="/my-file.pdf" scale={1.5}>
+  <Page pageIndex={0} />
+</Document>
+```
+
+`scale={1}` is the normal size. `scale={1.5}` makes it 50% bigger. `scale={0.5}` makes it half size.
+
+You can also zoom just one page differently from the rest:
+
+```tsx
+<Page pageIndex={0} scale={2} />
+```
+
+---
+
+## Rotating pages
+
+```tsx
+<Document file="/my-file.pdf" rotate={90}>
+  <Page pageIndex={0} />
+</Document>
+```
+
+Use `90`, `180`, or `270` degrees. Just like `scale`, you can also rotate a single page differently:
+
+```tsx
+<Page pageIndex={0} rotate={180} />
+```
+
+---
+
+## Turning text selection on or off
+
+By default, users can click and drag to select text on the page, then copy it — just like a real document.
+
+If you don't want this (for example, showing small page thumbnails), turn it off:
+
+```tsx
+<Page pageIndex={0} textSelectable={false} />
+```
+
+---
+
+## Opening password-protected PDFs
+
+```tsx
+<Document
+  file="/protected-file.pdf"
+  onPassword={(submitPassword) => {
+    const password = window.prompt('This PDF needs a password:');
+    submitPassword(password ?? '');
+  }}
+>
+  <Page pageIndex={0} />
+</Document>
+```
+
+When the library discovers the PDF needs a password, it calls your `onPassword` function. You ask the user for the password (however you like — a prompt box, a form, anything), and then call `submitPassword(theirAnswer)` to try opening it.
+
+---
+
+## Showing loading and error messages
+
+```tsx
+<Document
+  file="/my-file.pdf"
+  loading="Loading your document..."
+  error="Sorry, we couldn't open this PDF."
+>
+  <Page pageIndex={0} />
+</Document>
+```
+
+You can use plain text, or your own custom design:
+
+```tsx
+<Document
+  file="/my-file.pdf"
+  loading={<MySpinner />}
+  error={<MyErrorMessage />}
+>
+  <Page pageIndex={0} />
+</Document>
+```
+
+---
+
+## All the settings you can use
+
+### `<Document>` settings
+
+| Setting | What it does | Default |
+|---|---|---|
+| `file` | The PDF to show — a web address, an uploaded file, or raw file data. | *(required)* |
+| `scale` | How zoomed in the pages are. | `1` |
+| `rotate` | How many degrees to rotate the pages (`0`, `90`, `180`, `270`). | `0` |
+| `loading` | What to show while the PDF is loading. | `"Loading PDF…"` |
+| `error` | What to show if something goes wrong. | `"Failed to load PDF file."` |
+| `noData` | What to show if no file was given. | `"No PDF file specified."` |
+| `onLoadSuccess` | Runs when the PDF has finished loading. Tells you `numPages`. | — |
+| `onLoadError` | Runs if the PDF fails to load. | — |
+| `onLoadProgress` | Runs while the file is downloading, so you can show a progress bar. | — |
+| `onPassword` | Runs when a password-protected PDF needs unlocking. | — |
+| `className` | Add your own CSS class name(s) to the wrapper. | — |
+
+### `<Page>` settings
+
+| Setting | What it does | Default |
+|---|---|---|
+| `pageIndex` | Which page to show (starting at `0` for the first page). | *(required)* |
+| `scale` | Zoom for this page only (overrides the Document's setting). | inherited |
+| `rotate` | Rotation for this page only (overrides the Document's setting). | inherited |
+| `textSelectable` | Whether people can select and copy text on this page. | `true` |
+
+---
+
+## Using it without the internet
+
+By default, this library downloads a small "PDF engine" file from a free content-delivery service the first time it's needed. For most people, this just works with zero setup.
+
+If you're building something for a company network that blocks outside websites, or an app that needs to work completely offline, you can host these files yourself instead:
+
+**1. Download the two engine files:**
+
+- [`pdfium.js`](https://cdn.jsdelivr.net/npm/pdf-viewer-assets@1.0.0/pdfium.js)
+- [`pdfium.wasm`](https://cdn.jsdelivr.net/npm/pdf-viewer-assets@1.0.0/pdfium.wasm)
+
+**2. Put both files in your app's `public` folder.**
+
+**3. Tell the library to use your own copies, before showing any PDF:**
+
+```tsx
+import { setPdfiumSource } from 'react-pdf-viewer-wasm';
+
+setPdfiumSource({
+  jsUrl: '/pdfium.js',
+  wasmUrl: '/pdfium.wasm',
+});
+```
+
+Do this once, near the very start of your app (for example, in your main entry file), before any `<Document>` is shown.
+
+---
+
+## What's not supported yet
+
+This is a young library, and being upfront about its current limits:
+
+- **No clickable links or bookmarks inside PDFs yet.**
+- **No PDF forms yet** (fillable fields, checkboxes, etc.).
+- **Large PDFs may feel a little slow** — page rendering currently happens on the main part of your browser's engine, so very big or complex PDFs might cause a brief pause while rendering. Improving this is planned.
+
+If any of these matter for what you're building, keep that in mind before relying on this library for a big project just yet.
+
+---
+
+## Requirements
+
+- React 18 or newer
+- Any modern web browser (Chrome, Firefox, Safari, Edge — all support what this library needs)
+
+---
+
+## License
+
+MIT
+
+---
+
+## Credits
+
+- [pdfium](https://pdfium.googlesource.com/pdfium/) — the actual PDF engine, made by Google.
+- [pdfium-render](https://github.com/ajrcarey/pdfium-render) — the Rust tool this library is built on top of.
+- [pdfium-lib](https://github.com/paulocoutinhox/pdfium-lib) — provides the ready-to-use engine files.