modern-pdf-lib 0.9.0

package/dist/libdeflateWasm-QVHmuzw-.mjs

@@ -0,0 +1,220 @@
+import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+
+//#region src/compression/libdeflateWasm.ts
+var libdeflateWasm_exports = /* @__PURE__ */ __exportAll({
+	LibdeflateWasm: () => LibdeflateWasm,
+	deflateSync: () => deflateSync,
+	dispose: () => dispose,
+	inflateSync: () => inflateSync,
+	initDeflateWasm: () => initDeflateWasm,
+	isAvailable: () => isAvailable
+});
+/** The instantiated WASM module exports, or `null` if not yet loaded. */
+let wasmExports = null;
+/** Whether initialization has been attempted. */
+let initAttempted = false;
+/** Whether the WASM module is ready for use. */
+let available = false;
+/**
+* Get a view of the WASM linear memory.
+*
+* This must be called fresh each time because growing the WASM memory
+* invalidates prior `Uint8Array` views.
+*/
+function wasmMemory() {
+	if (!wasmExports) throw new Error("libdeflate WASM not initialized");
+	return new Uint8Array(wasmExports.memory.buffer);
+}
+/**
+* Copy data into WASM linear memory at the given pointer.
+*
+* @param ptr  - Target pointer in WASM memory.
+* @param data - Source bytes to copy.
+*/
+function copyToWasm(ptr, data) {
+	wasmMemory().set(data, ptr);
+}
+/**
+* Copy data out of WASM linear memory.
+*
+* @param ptr - Source pointer in WASM memory.
+* @param len - Number of bytes to copy.
+* @returns     A new Uint8Array with the copied data.
+*/
+function copyFromWasm(ptr, len) {
+	const copy = new Uint8Array(len);
+	copy.set(wasmMemory().subarray(ptr, ptr + len));
+	return copy;
+}
+/**
+* Initialize the libdeflate WASM module.
+*
+* This must be called before using {@link LibdeflateWasm} or the
+* synchronous helpers. It is safe to call multiple times -- subsequent
+* calls are no-ops.
+*
+* @param wasmBytes - Optional pre-loaded WASM binary. When omitted,
+*                    the module is loaded via the universal WASM loader
+*                    (see `src/wasm/loader.ts`).
+* @throws If the WASM module cannot be loaded or instantiated.
+*
+* @example
+* ```ts
+* // Auto-load from default location
+* await initDeflateWasm();
+*
+* // Or provide bytes directly (e.g. bundled)
+* await initDeflateWasm(myWasmBytes);
+* ```
+*/
+async function initDeflateWasm(wasmBytes) {
+	if (available) return;
+	if (initAttempted) return;
+	initAttempted = true;
+	try {
+		let bytes;
+		if (wasmBytes) bytes = wasmBytes;
+		else {
+			const { loadWasmModule } = await import("./loader-D9LTYmrX.mjs");
+			bytes = await loadWasmModule("libdeflate");
+		}
+		const compiled = await WebAssembly.compile(new Uint8Array(bytes));
+		wasmExports = (await WebAssembly.instantiate(compiled, {})).exports;
+		available = true;
+	} catch (err) {
+		wasmExports = null;
+		available = false;
+		throw new Error(`Failed to initialize libdeflate WASM: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+/**
+* Synchronously compress data using libdeflate WASM.
+*
+* The WASM module must already be initialized via {@link initDeflateWasm}.
+*
+* @param input - Uncompressed bytes.
+* @param level - Compression level 1-12. Default: `6`.
+* @returns       Compressed bytes (raw deflate).
+* @throws If WASM is not initialized.
+*
+* @example
+* ```ts
+* await initDeflateWasm(bytes);
+* const compressed = deflateSync(myData, 9);
+* ```
+*/
+function deflateSync(input, level = 6) {
+	if (!wasmExports) throw new Error("libdeflate WASM not initialized. Call initDeflateWasm() first.");
+	const clampedLevel = Math.max(1, Math.min(12, Math.round(level)));
+	const maxOutputSize = input.length + Math.ceil(input.length / 16) + 64 + 3;
+	const inputPtr = wasmExports.alloc(input.length);
+	const outputPtr = wasmExports.alloc(maxOutputSize);
+	try {
+		copyToWasm(inputPtr, input);
+		const actualSize = wasmExports.compress(inputPtr, input.length, outputPtr, maxOutputSize, clampedLevel);
+		if (actualSize <= 0) throw new Error("libdeflate compression failed (returned zero or negative size)");
+		return copyFromWasm(outputPtr, actualSize);
+	} finally {
+		wasmExports.dealloc(inputPtr, input.length);
+		wasmExports.dealloc(outputPtr, maxOutputSize);
+	}
+}
+/**
+* Synchronously decompress raw deflate data using libdeflate WASM.
+*
+* @param input      - Compressed bytes (raw deflate).
+* @param outputSize - Maximum expected output size. Must be >= actual
+*                     decompressed size. Default: `input.length * 4`.
+* @returns            Decompressed bytes.
+* @throws If WASM is not initialized or decompression fails.
+*
+* @example
+* ```ts
+* const original = inflateSync(compressed, knownOriginalSize);
+* ```
+*/
+function inflateSync(input, outputSize = input.length * 4) {
+	if (!wasmExports) throw new Error("libdeflate WASM not initialized. Call initDeflateWasm() first.");
+	const maxOutput = Math.max(outputSize, input.length * 2);
+	const inputPtr = wasmExports.alloc(input.length);
+	const outputPtr = wasmExports.alloc(maxOutput);
+	try {
+		copyToWasm(inputPtr, input);
+		const actualSize = wasmExports.decompress(inputPtr, input.length, outputPtr, maxOutput);
+		if (actualSize < 0) throw new Error("libdeflate decompression failed. The input may be corrupt or the output buffer may be too small.");
+		return copyFromWasm(outputPtr, actualSize);
+	} finally {
+		wasmExports.dealloc(inputPtr, input.length);
+		wasmExports.dealloc(outputPtr, maxOutput);
+	}
+}
+/**
+* Check whether the libdeflate WASM module is initialized and available.
+*
+* @returns `true` if WASM is ready for use.
+*/
+function isAvailable() {
+	return available;
+}
+/**
+* Release the WASM module and free associated resources.
+*
+* After calling this, the module must be re-initialized with
+* {@link initDeflateWasm} before further use.
+*/
+function dispose() {
+	wasmExports = null;
+	available = false;
+	initAttempted = false;
+}
+/**
+* A {@link CompressionEngine} backed by libdeflate compiled to WASM.
+*
+* This provides the fastest compression available in the library,
+* with support for levels 1-12 (libdeflate's native range).
+*
+* The WASM module must be initialized before constructing this class.
+* Use {@link initDeflateWasm} to load the module.
+*
+* @example
+* ```ts
+* await initDeflateWasm(wasmBytes);
+* const engine = new LibdeflateWasm();
+* const compressed = await engine.compress(data, 6);
+* ```
+*/
+var LibdeflateWasm = class {
+	name = "libdeflate-wasm";
+	minLevel = 1;
+	maxLevel = 12;
+	/**
+	* Compress data using libdeflate WASM.
+	*
+	* @param data  - Uncompressed input bytes.
+	* @param level - Compression level 1-12 (clamped). Default: `6`.
+	* @returns       Compressed bytes (raw deflate).
+	*/
+	async compress(data, level = 6) {
+		return deflateSync(data, level);
+	}
+	/**
+	* Decompress raw deflate data using libdeflate WASM.
+	*
+	* @param data       - Compressed bytes (raw deflate).
+	* @param outputSize - Expected output size hint. Default: `data.length * 4`.
+	* @returns            Decompressed bytes.
+	*/
+	async decompress(data, outputSize) {
+		return inflateSync(data, outputSize);
+	}
+	/**
+	* Release the WASM module resources.
+	*/
+	dispose() {
+		dispose();
+	}
+};
+
+//#endregion
+export { isAvailable as n, libdeflateWasm_exports as r, deflateSync as t };
+//# sourceMappingURL=libdeflateWasm-QVHmuzw-.mjs.map

package/dist/libdeflateWasm-to2bG6NG.cjs

@@ -0,0 +1,237 @@
+const require_rolldown_runtime = require('./rolldown-runtime-CKhH4XqG.cjs');
+
+//#region src/compression/libdeflateWasm.ts
+var libdeflateWasm_exports = /* @__PURE__ */ require_rolldown_runtime.__exportAll({
+	LibdeflateWasm: () => LibdeflateWasm,
+	deflateSync: () => deflateSync,
+	dispose: () => dispose,
+	inflateSync: () => inflateSync,
+	initDeflateWasm: () => initDeflateWasm,
+	isAvailable: () => isAvailable
+});
+/** The instantiated WASM module exports, or `null` if not yet loaded. */
+let wasmExports = null;
+/** Whether initialization has been attempted. */
+let initAttempted = false;
+/** Whether the WASM module is ready for use. */
+let available = false;
+/**
+* Get a view of the WASM linear memory.
+*
+* This must be called fresh each time because growing the WASM memory
+* invalidates prior `Uint8Array` views.
+*/
+function wasmMemory() {
+	if (!wasmExports) throw new Error("libdeflate WASM not initialized");
+	return new Uint8Array(wasmExports.memory.buffer);
+}
+/**
+* Copy data into WASM linear memory at the given pointer.
+*
+* @param ptr  - Target pointer in WASM memory.
+* @param data - Source bytes to copy.
+*/
+function copyToWasm(ptr, data) {
+	wasmMemory().set(data, ptr);
+}
+/**
+* Copy data out of WASM linear memory.
+*
+* @param ptr - Source pointer in WASM memory.
+* @param len - Number of bytes to copy.
+* @returns     A new Uint8Array with the copied data.
+*/
+function copyFromWasm(ptr, len) {
+	const copy = new Uint8Array(len);
+	copy.set(wasmMemory().subarray(ptr, ptr + len));
+	return copy;
+}
+/**
+* Initialize the libdeflate WASM module.
+*
+* This must be called before using {@link LibdeflateWasm} or the
+* synchronous helpers. It is safe to call multiple times -- subsequent
+* calls are no-ops.
+*
+* @param wasmBytes - Optional pre-loaded WASM binary. When omitted,
+*                    the module is loaded via the universal WASM loader
+*                    (see `src/wasm/loader.ts`).
+* @throws If the WASM module cannot be loaded or instantiated.
+*
+* @example
+* ```ts
+* // Auto-load from default location
+* await initDeflateWasm();
+*
+* // Or provide bytes directly (e.g. bundled)
+* await initDeflateWasm(myWasmBytes);
+* ```
+*/
+async function initDeflateWasm(wasmBytes) {
+	if (available) return;
+	if (initAttempted) return;
+	initAttempted = true;
+	try {
+		let bytes;
+		if (wasmBytes) bytes = wasmBytes;
+		else {
+			const { loadWasmModule } = await Promise.resolve().then(() => require("./loader-mwt5wRJz.cjs"));
+			bytes = await loadWasmModule("libdeflate");
+		}
+		const compiled = await WebAssembly.compile(new Uint8Array(bytes));
+		wasmExports = (await WebAssembly.instantiate(compiled, {})).exports;
+		available = true;
+	} catch (err) {
+		wasmExports = null;
+		available = false;
+		throw new Error(`Failed to initialize libdeflate WASM: ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+/**
+* Synchronously compress data using libdeflate WASM.
+*
+* The WASM module must already be initialized via {@link initDeflateWasm}.
+*
+* @param input - Uncompressed bytes.
+* @param level - Compression level 1-12. Default: `6`.
+* @returns       Compressed bytes (raw deflate).
+* @throws If WASM is not initialized.
+*
+* @example
+* ```ts
+* await initDeflateWasm(bytes);
+* const compressed = deflateSync(myData, 9);
+* ```
+*/
+function deflateSync(input, level = 6) {
+	if (!wasmExports) throw new Error("libdeflate WASM not initialized. Call initDeflateWasm() first.");
+	const clampedLevel = Math.max(1, Math.min(12, Math.round(level)));
+	const maxOutputSize = input.length + Math.ceil(input.length / 16) + 64 + 3;
+	const inputPtr = wasmExports.alloc(input.length);
+	const outputPtr = wasmExports.alloc(maxOutputSize);
+	try {
+		copyToWasm(inputPtr, input);
+		const actualSize = wasmExports.compress(inputPtr, input.length, outputPtr, maxOutputSize, clampedLevel);
+		if (actualSize <= 0) throw new Error("libdeflate compression failed (returned zero or negative size)");
+		return copyFromWasm(outputPtr, actualSize);
+	} finally {
+		wasmExports.dealloc(inputPtr, input.length);
+		wasmExports.dealloc(outputPtr, maxOutputSize);
+	}
+}
+/**
+* Synchronously decompress raw deflate data using libdeflate WASM.
+*
+* @param input      - Compressed bytes (raw deflate).
+* @param outputSize - Maximum expected output size. Must be >= actual
+*                     decompressed size. Default: `input.length * 4`.
+* @returns            Decompressed bytes.
+* @throws If WASM is not initialized or decompression fails.
+*
+* @example
+* ```ts
+* const original = inflateSync(compressed, knownOriginalSize);
+* ```
+*/
+function inflateSync(input, outputSize = input.length * 4) {
+	if (!wasmExports) throw new Error("libdeflate WASM not initialized. Call initDeflateWasm() first.");
+	const maxOutput = Math.max(outputSize, input.length * 2);
+	const inputPtr = wasmExports.alloc(input.length);
+	const outputPtr = wasmExports.alloc(maxOutput);
+	try {
+		copyToWasm(inputPtr, input);
+		const actualSize = wasmExports.decompress(inputPtr, input.length, outputPtr, maxOutput);
+		if (actualSize < 0) throw new Error("libdeflate decompression failed. The input may be corrupt or the output buffer may be too small.");
+		return copyFromWasm(outputPtr, actualSize);
+	} finally {
+		wasmExports.dealloc(inputPtr, input.length);
+		wasmExports.dealloc(outputPtr, maxOutput);
+	}
+}
+/**
+* Check whether the libdeflate WASM module is initialized and available.
+*
+* @returns `true` if WASM is ready for use.
+*/
+function isAvailable() {
+	return available;
+}
+/**
+* Release the WASM module and free associated resources.
+*
+* After calling this, the module must be re-initialized with
+* {@link initDeflateWasm} before further use.
+*/
+function dispose() {
+	wasmExports = null;
+	available = false;
+	initAttempted = false;
+}
+/**
+* A {@link CompressionEngine} backed by libdeflate compiled to WASM.
+*
+* This provides the fastest compression available in the library,
+* with support for levels 1-12 (libdeflate's native range).
+*
+* The WASM module must be initialized before constructing this class.
+* Use {@link initDeflateWasm} to load the module.
+*
+* @example
+* ```ts
+* await initDeflateWasm(wasmBytes);
+* const engine = new LibdeflateWasm();
+* const compressed = await engine.compress(data, 6);
+* ```
+*/
+var LibdeflateWasm = class {
+	name = "libdeflate-wasm";
+	minLevel = 1;
+	maxLevel = 12;
+	/**
+	* Compress data using libdeflate WASM.
+	*
+	* @param data  - Uncompressed input bytes.
+	* @param level - Compression level 1-12 (clamped). Default: `6`.
+	* @returns       Compressed bytes (raw deflate).
+	*/
+	async compress(data, level = 6) {
+		return deflateSync(data, level);
+	}
+	/**
+	* Decompress raw deflate data using libdeflate WASM.
+	*
+	* @param data       - Compressed bytes (raw deflate).
+	* @param outputSize - Expected output size hint. Default: `data.length * 4`.
+	* @returns            Decompressed bytes.
+	*/
+	async decompress(data, outputSize) {
+		return inflateSync(data, outputSize);
+	}
+	/**
+	* Release the WASM module resources.
+	*/
+	dispose() {
+		dispose();
+	}
+};
+
+//#endregion
+Object.defineProperty(exports, 'deflateSync', {
+  enumerable: true,
+  get: function () {
+    return deflateSync;
+  }
+});
+Object.defineProperty(exports, 'isAvailable', {
+  enumerable: true,
+  get: function () {
+    return isAvailable;
+  }
+});
+Object.defineProperty(exports, 'libdeflateWasm_exports', {
+  enumerable: true,
+  get: function () {
+    return libdeflateWasm_exports;
+  }
+});
+//# sourceMappingURL=libdeflateWasm-to2bG6NG.cjs.map

package/dist/loader-D9LTYmrX.mjs

@@ -0,0 +1,162 @@
+//#region src/wasm/loader.ts
+/** Map of module names to their default `.wasm` filenames. */
+const DEFAULT_FILENAMES = {
+	libdeflate: "modern_pdf_deflate_bg.wasm",
+	png: "modern_pdf_png_bg.wasm",
+	ttf: "modern_pdf_ttf_bg.wasm",
+	shaping: "modern_pdf_shaping_bg.wasm"
+};
+/** Cached loaded WASM modules. */
+const moduleCache = /* @__PURE__ */ new Map();
+/** Global loader configuration. */
+let globalConfig = {};
+/**
+* Detect the current JavaScript runtime environment.
+*
+* @returns The detected runtime kind.
+*
+* @example
+* ```ts
+* const runtime = detectRuntime();
+* if (runtime === 'node') { ... }
+* ```
+*/
+function detectRuntime() {
+	if (typeof globalThis !== "undefined" && "caches" in globalThis && typeof globalThis["HTMLElement"] === "undefined" && typeof globalThis["process"] === "undefined") {
+		if (typeof globalThis["navigator"] === "object") {
+			if ((globalThis.navigator?.userAgent ?? "").includes("Cloudflare-Workers")) return "workerd";
+		}
+	}
+	if (typeof globalThis["Deno"] === "object") return "deno";
+	if (typeof globalThis["Bun"] === "object") return "bun";
+	if (typeof globalThis["process"] === "object" && typeof globalThis["process"]?.["versions"] === "object" && typeof (globalThis["process"]?.["versions"])?.["node"] === "string") return "node";
+	if (typeof globalThis.document === "object" || typeof globalThis.window === "object") return "browser";
+	return "unknown";
+}
+/**
+* Get the current WASM loader configuration (for testing/inspection).
+*/
+function getWasmLoaderConfig() {
+	return globalConfig;
+}
+/**
+* Load WASM bytes using `fetch()` (works in browsers, Deno, Bun, and
+* Node.js 18+).
+*
+* @param url - URL or path to the `.wasm` file.
+* @returns     The raw WASM bytes.
+*/
+async function loadViaFetch(url) {
+	const response = await fetch(url);
+	if (!response.ok) throw new Error(`Failed to fetch WASM module: ${response.status} ${response.statusText} (${url})`);
+	const buffer = await response.arrayBuffer();
+	return new Uint8Array(buffer);
+}
+/**
+* Load WASM bytes from the filesystem using Node.js `fs/promises`.
+*
+* Uses dynamic import to avoid top-level CJS dependency.
+*
+* @param filePath - Absolute or relative filesystem path.
+* @returns          The raw WASM bytes.
+*/
+async function loadViaNodeFs(filePath) {
+	try {
+		const { readFile } = await import("node:fs/promises");
+		const buffer = await readFile(filePath);
+		return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
+	} catch (err) {
+		throw new Error(`Failed to load WASM module from filesystem: ${filePath} -- ${err instanceof Error ? err.message : String(err)}`);
+	}
+}
+/**
+* Resolve the path/URL for a WASM module given its name.
+*
+* Resolution order:
+* 1. `config.modulePaths[name]` (explicit per-module path)
+* 2. `config.basePath + DEFAULT_FILENAMES[name]` (base path + default name)
+* 3. Relative to the package directory (best-effort)
+*
+* @param name   - Module name (e.g. `'libdeflate'`).
+* @param config - Current loader config.
+* @param runtime - Detected runtime.
+* @returns        Resolved path or URL string.
+*/
+function resolveModulePath(name, config, runtime) {
+	if (config.modulePaths?.[name]) return config.modulePaths[name];
+	const filename = DEFAULT_FILENAMES[name];
+	if (!filename) throw new Error(`Unknown WASM module: "${name}". Known modules: ${Object.keys(DEFAULT_FILENAMES).join(", ")}`);
+	if (config.basePath) return `${config.basePath.endsWith("/") ? config.basePath : `${config.basePath}/`}${filename}`;
+	switch (runtime) {
+		case "browser": return `/wasm/${filename}`;
+		case "node":
+		case "bun": try {
+			return new URL(`../wasm/${name}/pkg/${filename}`, import.meta.url).pathname;
+		} catch {
+			return `./wasm/${name}/pkg/${filename}`;
+		}
+		case "deno": try {
+			return new URL(`../wasm/${name}/pkg/${filename}`, import.meta.url).href;
+		} catch {
+			return `./wasm/${name}/pkg/${filename}`;
+		}
+		case "workerd": throw new Error(`Cannot auto-resolve WASM path in Workers/Edge runtime. Provide WASM bytes via configureWasmLoader({ moduleBytes: { ${name}: bytes } }) or use modulePaths configuration.`);
+		default: return `./wasm/${name}/pkg/${filename}`;
+	}
+}
+/**
+* Load a WASM module by name.
+*
+* Returns the raw `.wasm` bytes, suitable for passing to
+* `WebAssembly.compile()` or `WebAssembly.instantiate()`.
+*
+* Results are cached -- subsequent calls for the same module name
+* return the cached bytes without re-fetching.
+*
+* @param name - Module name. One of: `'libdeflate'`, `'png'`, `'ttf'`, `'shaping'`.
+* @returns      The raw WASM bytes.
+* @throws If the module cannot be loaded in the current runtime.
+*
+* @example
+* ```ts
+* // Auto-detect runtime and load
+* const wasmBytes = await loadWasmModule('libdeflate');
+*
+* // Pre-configure for Workers
+* configureWasmLoader({ moduleBytes: { libdeflate: bundledBytes } });
+* const bytes = await loadWasmModule('libdeflate');
+* ```
+*/
+async function loadWasmModule(name) {
+	const cached = moduleCache.get(name);
+	if (cached) return cached;
+	if (globalConfig.moduleBytes?.[name]) {
+		const bytes = globalConfig.moduleBytes[name];
+		moduleCache.set(name, bytes);
+		return bytes;
+	}
+	const runtime = detectRuntime();
+	const modulePath = resolveModulePath(name, globalConfig, runtime);
+	let bytes;
+	switch (runtime) {
+		case "node":
+			if (modulePath.startsWith("http://") || modulePath.startsWith("https://")) bytes = await loadViaFetch(modulePath);
+			else bytes = await loadViaNodeFs(modulePath);
+			break;
+		case "deno":
+		case "bun":
+		case "browser":
+			bytes = await loadViaFetch(modulePath);
+			break;
+		case "workerd": throw new Error(`WASM module "${name}" cannot be auto-loaded in Workers/Edge. Provide bytes via configureWasmLoader().`);
+		default:
+			bytes = await loadViaFetch(modulePath);
+			break;
+	}
+	moduleCache.set(name, bytes);
+	return bytes;
+}
+
+//#endregion
+export { getWasmLoaderConfig, loadWasmModule };
+//# sourceMappingURL=loader-D9LTYmrX.mjs.map