@docmentis/udoc-viewer 0.5.9 → 0.5.11

package/dist/src/worker/worker.js

@@ -1,237 +1,1906 @@
-/**
- * Web Worker for UDoc document rendering.
- *
- * Handles WASM operations off the main thread to keep the UI responsive.
- */
-import init, { UDoc } from "../wasm/udoc.js";
-let udoc = null;
-/** Current request ID for response matching. */
-let currentRequestId;
-/**
- * Handle incoming messages from main thread.
- */
-self.onmessage = async (event) => {
-    const { _id, ...request } = event.data;
-    currentRequestId = _id;
-    try {
-        switch (request.type) {
-            case "init": {
-                await init(request.wasmUrl);
-                udoc = new UDoc();
-                respond({ type: "init", success: true });
-                break;
-            }
-            case "setLicense": {
-                ensureInitialized();
-                const result = udoc.set_license(request.license, request.domain);
-                respond({ type: "setLicense", success: true, result });
-                break;
-            }
-            case "getLicenseStatus": {
-                ensureInitialized();
-                const result = udoc.license_status();
-                respond({ type: "getLicenseStatus", success: true, result });
-                break;
-            }
-            case "loadPdf": {
-                ensureInitialized();
-                const documentId = udoc.load_pdf(request.bytes);
-                respond({ type: "loadPdf", success: true, documentId });
-                break;
-            }
-            case "loadImage": {
-                ensureInitialized();
-                const documentId = udoc.load_image(request.bytes);
-                respond({ type: "loadImage", success: true, documentId });
-                break;
-            }
-            case "loadPptx": {
-                ensureInitialized();
-                const documentId = udoc.load_pptx(request.bytes);
-                respond({ type: "loadPptx", success: true, documentId });
-                break;
-            }
-            case "unloadPdf": {
-                ensureInitialized();
-                const removed = udoc.remove_document(request.documentId);
-                respond({ type: "unloadPdf", success: true, removed });
-                break;
-            }
-            case "needsPassword": {
-                ensureInitialized();
-                const needsPassword = udoc.needs_password(request.documentId);
-                respond({ type: "needsPassword", success: true, needsPassword });
-                break;
-            }
-            case "authenticate": {
-                ensureInitialized();
-                const authenticated = udoc.authenticate(request.documentId, request.password);
-                respond({ type: "authenticate", success: true, authenticated });
-                break;
-            }
-            case "getPageCount": {
-                ensureInitialized();
-                const pageCount = udoc.page_count(request.documentId);
-                respond({ type: "getPageCount", success: true, pageCount });
-                break;
-            }
-            case "getPageInfo": {
-                ensureInitialized();
-                const info = udoc.page_info(request.documentId, request.pageIndex);
-                respond({ type: "getPageInfo", success: true, width: info.width, height: info.height, rotation: info.rotation });
-                break;
-            }
-            case "getAllPageInfo": {
-                ensureInitialized();
-                const pages = udoc.all_page_info(request.documentId);
-                respond({ type: "getAllPageInfo", success: true, pages });
-                break;
-            }
-            case "getPageLayout": {
-                ensureInitialized();
-                const layout = udoc.page_layout(request.documentId);
-                respond({ type: "getPageLayout", success: true, layout });
-                break;
-            }
-            case "renderPage": {
-                ensureInitialized();
-                const rgba = udoc.render_page_to_rgba(request.documentId, request.pageIndex, request.width, request.height);
-                respond({ type: "renderPage", success: true, rgba, width: request.width, height: request.height }, [rgba.buffer]);
-                break;
-            }
-            case "getOutline": {
-                ensureInitialized();
-                const outline = udoc.get_outline(request.documentId);
-                respond({ type: "getOutline", success: true, outline });
-                break;
-            }
-            case "getPageAnnotations": {
-                ensureInitialized();
-                const annotations = udoc.get_page_annotations(request.documentId, request.pageIndex);
-                respond({ type: "getPageAnnotations", success: true, annotations });
-                break;
-            }
-            case "getPageText": {
-                ensureInitialized();
-                const text = udoc.get_page_text(request.documentId, request.pageIndex);
-                respond({ type: "getPageText", success: true, text });
-                break;
-            }
-            case "getAllAnnotations": {
-                ensureInitialized();
-                const annotations = udoc.get_all_annotations(request.documentId);
-                respond({ type: "getAllAnnotations", success: true, annotations });
-                break;
-            }
-            case "pdfCompose": {
-                ensureInitialized();
-                const documentIds = udoc.pdf_compose(request.compositions, request.docIds);
-                respond({ type: "pdfCompose", success: true, documentIds });
-                break;
-            }
-            case "getBytes": {
-                ensureInitialized();
-                const bytes = udoc.get_bytes(request.documentId);
-                respond({ type: "getBytes", success: true, bytes }, [bytes.buffer]);
-                break;
-            }
-            case "pdfSplitByOutline": {
-                ensureInitialized();
-                const result = udoc.pdf_split_by_outline(request.documentId, request.maxLevel, request.splitMidPage);
-                respond({ type: "pdfSplitByOutline", success: true, result });
-                break;
-            }
-            case "pdfExtractImages": {
-                ensureInitialized();
-                const rawImages = udoc.pdf_extract_images(request.documentId, request.convertRawToPng);
-                // Copy Uint8Array data to ensure proper transfer across worker boundary
-                // (WASM memory views don't survive structured clone when nested in objects)
-                const images = rawImages.map(img => ({
-                    ...img,
-                    data: new Uint8Array(img.data)
-                }));
-                const transfers = images.map(img => img.data.buffer);
-                respond({ type: "pdfExtractImages", success: true, images }, transfers);
-                break;
-            }
-            case "pdfExtractFonts": {
-                ensureInitialized();
-                const rawFonts = udoc.pdf_extract_fonts(request.documentId);
-                // Copy Uint8Array data to ensure proper transfer across worker boundary
-                // (WASM memory views don't survive structured clone when nested in objects)
-                const fonts = rawFonts.map(font => ({
-                    ...font,
-                    data: new Uint8Array(font.data)
-                }));
-                const transfers = fonts.map(font => font.data.buffer);
-                respond({ type: "pdfExtractFonts", success: true, fonts }, transfers);
-                break;
-            }
-            case "pdfCompress": {
-                ensureInitialized();
-                const compressedBytes = udoc.pdf_compress(request.documentId);
-                respond({ type: "pdfCompress", success: true, bytes: compressedBytes }, [compressedBytes.buffer]);
-                break;
-            }
-            case "pdfDecompress": {
-                ensureInitialized();
-                const decompressedBytes = udoc.pdf_decompress(request.documentId);
-                respond({ type: "pdfDecompress", success: true, bytes: decompressedBytes }, [decompressedBytes.buffer]);
-                break;
-            }
-            case "getRequiredFonts": {
-                ensureInitialized();
-                const fonts = udoc.getRequiredFonts(request.documentId);
-                respond({ type: "getRequiredFonts", success: true, fonts });
-                break;
-            }
-            case "registerFont": {
-                ensureInitialized();
-                udoc.registerFont(request.documentId, request.typeface, request.bold, request.italic, request.bytes);
-                respond({ type: "registerFont", success: true });
-                break;
-            }
-            case "hasRegisteredFont": {
-                ensureInitialized();
-                const hasFont = udoc.hasRegisteredFont(request.documentId, request.typeface, request.bold, request.italic);
-                respond({ type: "hasRegisteredFont", success: true, hasFont });
-                break;
-            }
-            case "registeredFontCount": {
-                ensureInitialized();
-                const count = udoc.registeredFontCount(request.documentId);
-                respond({ type: "registeredFontCount", success: true, count });
-                break;
-            }
-            case "enableGoogleFonts": {
-                ensureInitialized();
-                udoc.enableGoogleFonts(request.documentId);
-                respond({ type: "enableGoogleFonts", success: true });
-                break;
-            }
-            default: {
-                const _exhaustive = request;
-                throw new Error(`Unknown request type: ${request.type}`);
-            }
-        }
+// dist/src/wasm/udoc.js
+var wasm;
+function addHeapObject(obj) {
+  if (heap_next === heap.length) heap.push(heap.length + 1);
+  const idx = heap_next;
+  heap_next = heap[idx];
+  heap[idx] = obj;
+  return idx;
+}
+function debugString(val) {
+  const type = typeof val;
+  if (type == "number" || type == "boolean" || val == null) {
+    return `${val}`;
+  }
+  if (type == "string") {
+    return `"${val}"`;
+  }
+  if (type == "symbol") {
+    const description = val.description;
+    if (description == null) {
+      return "Symbol";
+    } else {
+      return `Symbol(${description})`;
+    }
+  }
+  if (type == "function") {
+    const name = val.name;
+    if (typeof name == "string" && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return "Function";
+    }
+  }
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = "[";
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ", " + debugString(val[i]);
+    }
+    debug += "]";
+    return debug;
+  }
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    return toString.call(val);
+  }
+  if (className == "Object") {
+    try {
+      return "Object(" + JSON.stringify(val) + ")";
+    } catch (_) {
+      return "Object";
+    }
+  }
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}
+${val.stack}`;
+  }
+  return className;
+}
+function dropObject(idx) {
+  if (idx < 132) return;
+  heap[idx] = heap_next;
+  heap_next = idx;
+}
+function getArrayJsValueFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  const mem = getDataViewMemory0();
+  const result = [];
+  for (let i = ptr; i < ptr + 4 * len; i += 4) {
+    result.push(takeObject(mem.getUint32(i, true)));
+  }
+  return result;
+}
+function getArrayU8FromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+var cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === void 0 && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return decodeText(ptr, len);
+}
+var cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+    cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+  }
+  return cachedUint8ArrayMemory0;
+}
+function getObject(idx) {
+  return heap[idx];
+}
+function handleError(f, args) {
+  try {
+    return f.apply(this, args);
+  } catch (e) {
+    wasm.__wbindgen_export3(addHeapObject(e));
+  }
+}
+var heap = new Array(128).fill(void 0);
+heap.push(void 0, null, true, false);
+var heap_next = heap.length;
+function isLikeNone(x) {
+  return x === void 0 || x === null;
+}
+function passArray8ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 1, 1) >>> 0;
+  getUint8ArrayMemory0().set(arg, ptr / 1);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
+function passStringToWasm0(arg, malloc, realloc) {
+  if (realloc === void 0) {
+    const buf = cachedTextEncoder.encode(arg);
+    const ptr2 = malloc(buf.length, 1) >>> 0;
+    getUint8ArrayMemory0().subarray(ptr2, ptr2 + buf.length).set(buf);
+    WASM_VECTOR_LEN = buf.length;
+    return ptr2;
+  }
+  let len = arg.length;
+  let ptr = malloc(len, 1) >>> 0;
+  const mem = getUint8ArrayMemory0();
+  let offset = 0;
+  for (; offset < len; offset++) {
+    const code = arg.charCodeAt(offset);
+    if (code > 127) break;
+    mem[ptr + offset] = code;
+  }
+  if (offset !== len) {
+    if (offset !== 0) {
+      arg = arg.slice(offset);
+    }
+    ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+    const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+    const ret = cachedTextEncoder.encodeInto(arg, view);
+    offset += ret.written;
+    ptr = realloc(ptr, len, offset, 1) >>> 0;
+  }
+  WASM_VECTOR_LEN = offset;
+  return ptr;
+}
+function takeObject(idx) {
+  const ret = getObject(idx);
+  dropObject(idx);
+  return ret;
+}
+var cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+var MAX_SAFARI_DECODE_BYTES = 2146435072;
+var numBytesDecoded = 0;
+function decodeText(ptr, len) {
+  numBytesDecoded += len;
+  if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+    cachedTextDecoder = new TextDecoder("utf-8", { ignoreBOM: true, fatal: true });
+    cachedTextDecoder.decode();
+    numBytesDecoded = len;
+  }
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+var cachedTextEncoder = new TextEncoder();
+if (!("encodeInto" in cachedTextEncoder)) {
+  cachedTextEncoder.encodeInto = function(arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+      read: arg.length,
+      written: buf.length
+    };
+  };
+}
+var WASM_VECTOR_LEN = 0;
+var __wbindgen_enum_XmlHttpRequestResponseType = ["", "arraybuffer", "blob", "document", "json", "text"];
+var UDocFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_udoc_free(ptr >>> 0, 1));
+var UDoc = class {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    UDocFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_udoc_free(ptr, 0);
+  }
+  /**
+   * Load an image file and return its ID.
+   *
+   * Supports various image formats: JPEG, PNG, GIF, BMP, TIFF, WebP, etc.
+   * Multi-page TIFF files will create a document with multiple pages.
+   *
+   * # Arguments
+   * * `bytes` - Raw image file data
+   *
+   * # Returns
+   * A unique document ID that can be used to reference this document.
+   * @param {Uint8Array} bytes
+   * @returns {string}
+   */
+  load_image(bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_load_image(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
     }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        respond({ type: request.type, success: false, error: errorMessage });
+  }
+  /**
+   * Get the page count of a document.
+   * @param {string} id
+   * @returns {number}
+   */
+  page_count(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_page_count(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return r0 >>> 0;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get the document outline (bookmarks/table of contents).
+   *
+   * Returns an array of outline items, where each item has:
+   * - `title`: Display text for the item
+   * - `destination`: Optional navigation destination with `pageIndex` and display parameters
+   * - `children`: Nested child items
+   *
+   * Returns an empty array if the document has no outline.
+   * @param {string} id
+   * @returns {any}
+   */
+  get_outline(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_get_outline(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Check if a feature is enabled by the current license.
+   * @param {string} feature
+   * @returns {boolean}
+   */
+  has_feature(feature) {
+    const ptr0 = passStringToWasm0(feature, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.udoc_has_feature(this.__wbg_ptr, ptr0, len0);
+    return ret !== 0;
+  }
+  /**
+   * Get the preferred page layout for two-page viewing modes.
+   *
+   * Returns one of:
+   * - `"default"` - Viewer decides based on document type
+   * - `"odd-pages-right"` - Odd pages on right (page 1 alone, then 2|3, 4|5...)
+   * - `"odd-pages-left"` - Odd pages on left (1|2, 3|4, 5|6...)
+   * @param {string} id
+   * @returns {string}
+   */
+  page_layout(id) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_page_layout(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * Compose new PDF documents by cherry-picking pages from source documents.
+   *
+   * The original documents remain unchanged.
+   *
+   * # Arguments
+   * * `compositions` - Array of compositions. Each composition is an array of picks.
+   *   Each pick is `{ doc: docIndex, pages: "0-2,4" }` where `docIndex` is the index
+   *   in the `doc_ids` array and `pages` is a page range string (0-based).
+   * * `doc_ids` - Array of document IDs to use as sources (order matters for doc indices)
+   *
+   * # Example
+   * ```js
+   * // Create two documents: first has pages 0-2 from doc A, second has page 0 from A and 1 from B
+   * const newDocIds = udoc.pdf_compose(
+   *   [
+   *     [{ doc: 0, pages: "0-2" }],
+   *     [{ doc: 0, pages: "0" }, { doc: 1, pages: "1" }]
+   *   ],
+   *   ["doc_0", "doc_1"]
+   * );
+   * ```
+   *
+   * # Returns
+   * Array of IDs for the newly created documents (one per composition).
+   * @param {any} compositions
+   * @param {any} doc_ids
+   * @returns {any}
+   */
+  pdf_compose(compositions, doc_ids) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.udoc_pdf_compose(retptr, this.__wbg_ptr, addHeapObject(compositions), addHeapObject(doc_ids));
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Set the license key.
+   *
+   * # Arguments
+   * * `license_key` - The license key string
+   * * `domain` - The current domain (from window.location.hostname)
+   *
+   * # Returns
+   * License validation result as JSON.
+   * @param {string} license_key
+   * @param {string} domain
+   * @returns {any}
+   */
+  set_license(license_key, domain) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(license_key, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(domain, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.udoc_set_license(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Authenticate with a password to unlock an encrypted document.
+   *
+   * # Arguments
+   * * `id` - Document ID
+   * * `password` - Password to try
+   *
+   * # Returns
+   * `true` if authentication succeeded, `false` if the password was incorrect.
+   * @param {string} id
+   * @param {string} password
+   * @returns {boolean}
+   */
+  authenticate(id, password) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(password, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.udoc_authenticate(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return r0 !== 0;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get all document IDs.
+   * @returns {string[]}
+   */
+  document_ids() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.udoc_document_ids(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+      wasm.__wbindgen_export4(r0, r1 * 4, 4);
+      return v1;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Check if a document with the given ID exists.
+   * @param {string} id
+   * @returns {boolean}
+   */
+  has_document(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.udoc_has_document(this.__wbg_ptr, ptr0, len0);
+    return ret !== 0;
+  }
+  /**
+   * Compress a PDF document.
+   *
+   * Saves the document with full compression options enabled:
+   * - Compress stream data using FlateDecode
+   * - Pack objects into compressed object streams (PDF 1.5+)
+   * - Use compressed xref streams (PDF 1.5+)
+   * - Remove unreferenced objects
+   *
+   * # Arguments
+   * * `doc_id` - Document ID to compress
+   *
+   * # Returns
+   * Compressed PDF data as Uint8Array
+   * @param {string} doc_id
+   * @returns {Uint8Array}
+   */
+  pdf_compress(doc_id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(doc_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_pdf_compress(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v2 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_export4(r0, r1 * 1, 1);
+      return v2;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get info for all pages in one call.
+   *
+   * Returns an array of `{width, height, rotation}` objects, one per page.
+   * More efficient than calling `page_info` for each page.
+   * @param {string} id
+   * @returns {any}
+   */
+  all_page_info(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_all_page_info(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get text content for a specific page (for text selection).
+   *
+   * Returns an array of text runs, each containing:
+   * - `text`: Unicode text string
+   * - `glyphs`: Positioned glyphs with character mappings
+   * - `fontSize`: Font size in points
+   * - `transform`: Combined transform matrix
+   * @param {string} id
+   * @param {number} page_index
+   * @returns {any}
+   */
+  get_page_text(id, page_index) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_get_page_text(retptr, this.__wbg_ptr, ptr0, len0, page_index);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Register a font from raw bytes.
+   *
+   * Use this to register external fonts (e.g., fetched from Google Fonts)
+   * so they can be used for document rendering.
+   *
+   * # Arguments
+   * * `id` - Document ID
+   * * `typeface` - The typeface name (must match what's in the document)
+   * * `bold` - Whether this is a bold variant
+   * * `italic` - Whether this is an italic variant
+   * * `bytes` - Raw font file data (TTF, OTF, WOFF, or WOFF2)
+   *
+   * # Example (JavaScript)
+   * ```js
+   * // Get required fonts
+   * const fonts = udoc.getRequiredFonts(docId);
+   *
+   * // Fetch and register each font
+   * for (const font of fonts) {
+   *     const url = `https://fonts.googleapis.com/css2?family=${font.typeface}`;
+   *     const fontBytes = await fetchFontBytes(url, font.bold, font.italic);
+   *     udoc.registerFont(docId, font.typeface, font.bold, font.italic, fontBytes);
+   * }
+   *
+   * // Now render with the registered fonts
+   * const pixels = udoc.renderPageToRgba(docId, 0, 800, 600);
+   * ```
+   * @param {string} id
+   * @param {string} typeface
+   * @param {boolean} bold
+   * @param {boolean} italic
+   * @param {Uint8Array} bytes
+   */
+  registerFont(id, typeface, bold, italic, bytes) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(typeface, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len1 = WASM_VECTOR_LEN;
+      const ptr2 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+      const len2 = WASM_VECTOR_LEN;
+      wasm.udoc_registerFont(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, bold, italic, ptr2, len2);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      if (r1) {
+        throw takeObject(r0);
+      }
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get the number of documents currently loaded.
+   * @returns {number}
+   */
+  get document_count() {
+    const ret = wasm.udoc_document_count(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * Get current license status.
+   * @returns {any}
+   */
+  license_status() {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      wasm.udoc_license_status(retptr, this.__wbg_ptr);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Check if a document requires a password to open.
+   *
+   * Returns `true` if the document is encrypted and requires authentication
+   * before pages can be loaded or rendered.
+   * @param {string} id
+   * @returns {boolean}
+   */
+  needs_password(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_needs_password(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return r0 !== 0;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
     }
+  }
+  /**
+   * Decompress a PDF document.
+   *
+   * Removes all filter encodings from streams, resulting in raw,
+   * uncompressed stream data. Useful for debugging or inspection.
+   *
+   * # Arguments
+   * * `doc_id` - Document ID to decompress
+   *
+   * # Returns
+   * Decompressed PDF data as Uint8Array
+   * @param {string} doc_id
+   * @returns {Uint8Array}
+   */
+  pdf_decompress(doc_id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(doc_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_pdf_decompress(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v2 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_export4(r0, r1 * 1, 1);
+      return v2;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Remove a document by ID.
+   *
+   * Returns true if the document was removed, false if it didn't exist.
+   * @param {string} id
+   * @returns {boolean}
+   */
+  remove_document(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.udoc_remove_document(this.__wbg_ptr, ptr0, len0);
+    return ret !== 0;
+  }
+  /**
+   * Extract all embedded fonts from a PDF document.
+   *
+   * # Arguments
+   * * `doc_id` - Document ID to extract fonts from
+   *
+   * # Returns
+   * Array of extracted font objects, each with:
+   * - `name`: Font name from the resource dictionary
+   * - `fontType`: Font type (Type1, TrueType, etc.)
+   * - `extension`: File extension (ttf, cff, t1, etc.)
+   * - `data`: Raw font data as Uint8Array
+   * @param {string} doc_id
+   * @returns {any}
+   */
+  pdf_extract_fonts(doc_id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(doc_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_pdf_extract_fonts(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get all external fonts required by the document.
+   *
+   * This scans all text content in loaded pages and returns font descriptors
+   * for fonts that are:
+   * - Not embedded in the document
+   * - Not standard PDF fonts (Helvetica, Times, Courier, etc.)
+   *
+   * Use this to determine which fonts need to be fetched from external sources
+   * (e.g., Google Fonts) before rendering.
+   *
+   * Note: This only scans pages that have been loaded. Call appropriate loading
+   * methods first to ensure the pages you need are scanned.
+   *
+   * # Arguments
+   * * `id` - Document ID
+   *
+   * # Returns
+   * Array of font descriptors: `[{ typeface: "Roboto", bold: false, italic: false }, ...]`
+   *
+   * # Example (JavaScript)
+   * ```js
+   * // Load document
+   * const docId = udoc.loadPdf(pdfBytes);
+   *
+   * // Load all pages to scan for fonts
+   * const pageCount = udoc.pageCount(docId);
+   * for (let i = 0; i < pageCount; i++) {
+   *     udoc.renderPageToRgba(docId, i, 1, 1); // Minimal render to load page
+   * }
+   *
+   * // Get required fonts
+   * const fonts = udoc.getRequiredFonts(docId);
+   * // fonts: [{ typeface: "Roboto", bold: false, italic: false }, ...]
+   * ```
+   * @param {string} id
+   * @returns {any}
+   */
+  getRequiredFonts(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_getRequiredFonts(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Extract all embedded images from a PDF document.
+   *
+   * # Arguments
+   * * `doc_id` - Document ID to extract images from
+   * * `convert_raw_to_png` - When true, converts raw pixel data to PNG format
+   *
+   * # Returns
+   * Array of extracted image objects, each with:
+   * - `name`: Image name from the resource dictionary
+   * - `format`: Image format (jpeg, png, jp2, etc.)
+   * - `width`: Width in pixels
+   * - `height`: Height in pixels
+   * - `data`: Raw image data as Uint8Array
+   * @param {string} doc_id
+   * @param {boolean} convert_raw_to_png
+   * @returns {any}
+   */
+  pdf_extract_images(doc_id, convert_raw_to_png) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(doc_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_pdf_extract_images(retptr, this.__wbg_ptr, ptr0, len0, convert_raw_to_png);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Render a page to PNG bytes.
+   *
+   * # Arguments
+   * * `id` - Document ID
+   * * `page_index` - Zero-based page index
+   * * `width` - Output width in pixels
+   * * `height` - Output height in pixels
+   *
+   * # Returns
+   * PNG-encoded image data as a byte array.
+   * @param {string} id
+   * @param {number} page_index
+   * @param {number} width
+   * @param {number} height
+   * @returns {Uint8Array}
+   */
+  render_page_to_png(id, page_index, width, height) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_render_page_to_png(retptr, this.__wbg_ptr, ptr0, len0, page_index, width, height);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v2 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_export4(r0, r1 * 1, 1);
+      return v2;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Enable Google Fonts for a document.
+   *
+   * When enabled, fonts that are not embedded in the document will be
+   * automatically fetched from Google Fonts during rendering.
+   *
+   * # Arguments
+   * * `id` - Document ID
+   *
+   * # Example (JavaScript)
+   * ```js
+   * // Enable Google Fonts for the document
+   * udoc.enableGoogleFonts(docId);
+   *
+   * // Now render pages - fonts will be fetched automatically
+   * const pixels = udoc.renderPageToRgba(docId, 0, 800, 600);
+   * ```
+   * @param {string} id
+   */
+  enableGoogleFonts(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_enableGoogleFonts(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      if (r1) {
+        throw takeObject(r0);
+      }
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get all annotations in the document, grouped by page index.
+   *
+   * Returns an object mapping page indices (as strings) to arrays of annotations.
+   * @param {string} id
+   * @returns {any}
+   */
+  get_all_annotations(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_get_all_annotations(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Check if a font is registered for a document.
+   *
+   * # Arguments
+   * * `id` - Document ID
+   * * `typeface` - The typeface name
+   * * `bold` - Whether to check for bold variant
+   * * `italic` - Whether to check for italic variant
+   *
+   * # Returns
+   * `true` if the font is registered, `false` otherwise.
+   * @param {string} id
+   * @param {string} typeface
+   * @param {boolean} bold
+   * @param {boolean} italic
+   * @returns {boolean}
+   */
+  hasRegisteredFont(id, typeface, bold, italic) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      const ptr1 = passStringToWasm0(typeface, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len1 = WASM_VECTOR_LEN;
+      wasm.udoc_hasRegisteredFont(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, bold, italic);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return r0 !== 0;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Render a page to raw RGBA pixel data.
+   *
+   * The returned data is in premultiplied alpha format, suitable for
+   * use with `ImageData` and canvas rendering.
+   *
+   * # Arguments
+   * * `id` - Document ID
+   * * `page_index` - Zero-based page index
+   * * `width` - Output width in pixels
+   * * `height` - Output height in pixels
+   *
+   * # Returns
+   * Raw RGBA pixel data (width * height * 4 bytes).
+   * @param {string} id
+   * @param {number} page_index
+   * @param {number} width
+   * @param {number} height
+   * @returns {Uint8Array}
+   */
+  render_page_to_rgba(id, page_index, width, height) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_render_page_to_rgba(retptr, this.__wbg_ptr, ptr0, len0, page_index, width, height);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v2 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_export4(r0, r1 * 1, 1);
+      return v2;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get annotations for a specific page.
+   *
+   * Returns an array of annotation objects for the given page.
+   * Uses per-page loading for efficiency (only loads the requested page).
+   * @param {string} id
+   * @param {number} page_index
+   * @returns {any}
+   */
+  get_page_annotations(id, page_index) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_get_page_annotations(retptr, this.__wbg_ptr, ptr0, len0, page_index);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Split a PDF document by its outline (bookmarks) structure.
+   *
+   * Creates multiple documents, one for each outline section at the specified level.
+   *
+   * # Arguments
+   * * `doc_id` - Document ID to split
+   * * `max_level` - Maximum outline level to consider (1 = top level only)
+   * * `split_mid_page` - When true, filters page content when sections share a page
+   *
+   * # Returns
+   * Object with:
+   * - `documentIds`: Array of IDs for the newly created documents
+   * - `sections`: Array of section info objects with `title`, `startPage`, `level`
+   * @param {string} doc_id
+   * @param {number} max_level
+   * @param {boolean} split_mid_page
+   * @returns {any}
+   */
+  pdf_split_by_outline(doc_id, max_level, split_mid_page) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(doc_id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_pdf_split_by_outline(retptr, this.__wbg_ptr, ptr0, len0, max_level, split_mid_page);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get the number of fonts registered for a document.
+   *
+   * # Arguments
+   * * `id` - Document ID
+   *
+   * # Returns
+   * The number of registered fonts.
+   * @param {string} id
+   * @returns {number}
+   */
+  registeredFontCount(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_registeredFontCount(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return r0 >>> 0;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Create a new document viewer.
+   */
+  constructor() {
+    const ret = wasm.udoc_new();
+    this.__wbg_ptr = ret >>> 0;
+    UDocFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Load a PDF document and return its ID.
+   *
+   * # Arguments
+   * * `bytes` - Raw PDF file data
+   *
+   * # Returns
+   * A unique document ID that can be used to reference this document.
+   * @param {Uint8Array} bytes
+   * @returns {string}
+   */
+  load_pdf(bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_load_pdf(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * Get the raw PDF bytes of a document.
+   *
+   * Returns the original PDF file data for the document.
+   * Returns an error if the document is not a PDF.
+   * @param {string} id
+   * @returns {Uint8Array}
+   */
+  get_bytes(id) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_get_bytes(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      if (r3) {
+        throw takeObject(r2);
+      }
+      var v2 = getArrayU8FromWasm0(r0, r1).slice();
+      wasm.__wbindgen_export4(r0, r1 * 1, 1);
+      return v2;
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
+  /**
+   * Get a numeric limit from the current license.
+   *
+   * Returns the limit value if set in the license, otherwise returns the default.
+   * @param {string} limit_name
+   * @param {bigint} _default
+   * @returns {bigint}
+   */
+  get_limit(limit_name, _default) {
+    const ptr0 = passStringToWasm0(limit_name, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.udoc_get_limit(this.__wbg_ptr, ptr0, len0, _default);
+    return BigInt.asUintN(64, ret);
+  }
+  /**
+   * Load a PPTX (PowerPoint) document and return its ID.
+   *
+   * # Arguments
+   * * `bytes` - Raw PPTX file data
+   *
+   * # Returns
+   * A unique document ID that can be used to reference this document.
+   * @param {Uint8Array} bytes
+   * @returns {string}
+   */
+  load_pptx(bytes) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_load_pptx(retptr, this.__wbg_ptr, ptr0, len0);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+      var ptr2 = r0;
+      var len2 = r1;
+      if (r3) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeObject(r2);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+      wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+  }
+  /**
+   * Get info for a specific page.
+   * @param {string} id
+   * @param {number} page_index
+   * @returns {any}
+   */
+  page_info(id, page_index) {
+    try {
+      const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+      const ptr0 = passStringToWasm0(id, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      const len0 = WASM_VECTOR_LEN;
+      wasm.udoc_page_info(retptr, this.__wbg_ptr, ptr0, len0, page_index);
+      var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+      var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+      var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+      if (r2) {
+        throw takeObject(r1);
+      }
+      return takeObject(r0);
+    } finally {
+      wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+  }
 };
-function ensureInitialized() {
-    if (!udoc) {
-        throw new Error("Worker not initialized. Call init first.");
+if (Symbol.dispose) UDoc.prototype[Symbol.dispose] = UDoc.prototype.free;
+var EXPECTED_RESPONSE_TYPES = /* @__PURE__ */ new Set(["basic", "cors", "default"]);
+async function __wbg_load(module2, imports) {
+  if (typeof Response === "function" && module2 instanceof Response) {
+    if (typeof WebAssembly.instantiateStreaming === "function") {
+      try {
+        return await WebAssembly.instantiateStreaming(module2, imports);
+      } catch (e) {
+        const validResponse = module2.ok && EXPECTED_RESPONSE_TYPES.has(module2.type);
+        if (validResponse && module2.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", e);
+        } else {
+          throw e;
+        }
+      }
+    }
+    const bytes = await module2.arrayBuffer();
+    return await WebAssembly.instantiate(bytes, imports);
+  } else {
+    const instance = await WebAssembly.instantiate(module2, imports);
+    if (instance instanceof WebAssembly.Instance) {
+      return { instance, module: module2 };
+    } else {
+      return instance;
     }
+  }
 }
-function respond(response, transfer) {
-    const message = currentRequestId !== undefined ? { ...response, _id: currentRequestId } : response;
-    if (transfer) {
-        self.postMessage(message, transfer);
+function __wbg_get_imports() {
+  const imports = {};
+  imports.wbg = {};
+  imports.wbg.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_Number_2d1dcfcf4ec51736 = function(arg0) {
+    const ret = Number(getObject(arg0));
+    return ret;
+  };
+  imports.wbg.__wbg_String_8f0eb39a4a4c2f66 = function(arg0, arg1) {
+    const ret = String(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg___wbindgen_bigint_get_as_i64_6e32f5e6aff02e1d = function(arg0, arg1) {
+    const v = getObject(arg1);
+    const ret = typeof v === "bigint" ? v : void 0;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+  };
+  imports.wbg.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+    const v = getObject(arg0);
+    const ret = typeof v === "boolean" ? v : void 0;
+    return isLikeNone(ret) ? 16777215 : ret ? 1 : 0;
+  };
+  imports.wbg.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+    const ret = debugString(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg___wbindgen_in_0d3e1e8f0c669317 = function(arg0, arg1) {
+    const ret = getObject(arg0) in getObject(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_bigint_0e1a2e3f55cfae27 = function(arg0) {
+    const ret = typeof getObject(arg0) === "bigint";
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+    const ret = typeof getObject(arg0) === "function";
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
+    const val = getObject(arg0);
+    const ret = typeof val === "object" && val !== null;
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
+    const ret = typeof getObject(arg0) === "string";
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+    const ret = getObject(arg0) === void 0;
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_jsval_eq_b6101cc9cef1fe36 = function(arg0, arg1) {
+    const ret = getObject(arg0) === getObject(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
+    const ret = getObject(arg0) == getObject(arg1);
+    return ret;
+  };
+  imports.wbg.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof obj === "number" ? obj : void 0;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+  };
+  imports.wbg.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof obj === "string" ? obj : void 0;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+  };
+  imports.wbg.__wbg_call_3020136f7a2d6e44 = function() {
+    return handleError(function(arg0, arg1, arg2) {
+      const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_call_abb4ff46ce38be40 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = getObject(arg0).call(getObject(arg1));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_crypto_574e78ad8b13b65f = function(arg0) {
+    const ret = getObject(arg0).crypto;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_debug_9d0c87ddda3dc485 = function(arg0) {
+    console.debug(getObject(arg0));
+  };
+  imports.wbg.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+    const ret = getObject(arg0).done;
+    return ret;
+  };
+  imports.wbg.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+      deferred0_0 = arg0;
+      deferred0_1 = arg1;
+      console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+      wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
     }
-    else {
-        self.postMessage(message);
+  };
+  imports.wbg.__wbg_error_7bc7d576a6aaf855 = function(arg0) {
+    console.error(getObject(arg0));
+  };
+  imports.wbg.__wbg_fromCodePoint_50facac709b76f67 = function() {
+    return handleError(function(arg0) {
+      const ret = String.fromCodePoint(arg0 >>> 0);
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_getRandomValues_b8f5dbd5f3995a9e = function() {
+    return handleError(function(arg0, arg1) {
+      getObject(arg0).getRandomValues(getObject(arg1));
+    }, arguments);
+  };
+  imports.wbg.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_get_af9dab7e9603ea93 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = Reflect.get(getObject(arg0), getObject(arg1));
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_get_with_ref_key_1dc361bd10053bfe = function(arg0, arg1) {
+    const ret = getObject(arg0)[getObject(arg1)];
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_info_ce6bcc489c22f6f0 = function(arg0) {
+    console.info(getObject(arg0));
+  };
+  imports.wbg.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
+    let result;
+    try {
+      result = getObject(arg0) instanceof ArrayBuffer;
+    } catch (_) {
+      result = false;
     }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+    let result;
+    try {
+      result = getObject(arg0) instanceof Uint8Array;
+    } catch (_) {
+      result = false;
+    }
+    const ret = result;
+    return ret;
+  };
+  imports.wbg.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+  };
+  imports.wbg.__wbg_isSafeInteger_ae7d3f054d55fa16 = function(arg0) {
+    const ret = Number.isSafeInteger(getObject(arg0));
+    return ret;
+  };
+  imports.wbg.__wbg_iterator_27b7c8b35ab3e86b = function() {
+    const ret = Symbol.iterator;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_length_22ac23eaec9d8053 = function(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+  };
+  imports.wbg.__wbg_length_d45040a40c570362 = function(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+  };
+  imports.wbg.__wbg_log_1d990106d99dacb7 = function(arg0) {
+    console.log(getObject(arg0));
+  };
+  imports.wbg.__wbg_msCrypto_a61aeb35a24c1329 = function(arg0) {
+    const ret = getObject(arg0).msCrypto;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_1ba21ce319a06297 = function() {
+    const ret = new Object();
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_25f239778d6112b9 = function() {
+    const ret = new Array();
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_4fe05c96062a8385 = function() {
+    return handleError(function() {
+      const ret = new XMLHttpRequest();
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+    const ret = new Uint8Array(getObject(arg0));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_8a6f238a6ece86ea = function() {
+    const ret = new Error();
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_b546ae120718850e = function() {
+    const ret = /* @__PURE__ */ new Map();
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_new_with_length_aa5eaf41d35235e5 = function(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_next_138a17bbf04e926c = function(arg0) {
+    const ret = getObject(arg0).next;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_next_3cfe5c0fe2a4cc53 = function() {
+    return handleError(function(arg0) {
+      const ret = getObject(arg0).next();
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_node_905d3e251edff8a2 = function(arg0) {
+    const ret = getObject(arg0).node;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_now_69d776cd24f5215b = function() {
+    const ret = Date.now();
+    return ret;
+  };
+  imports.wbg.__wbg_open_bfb661c1c2740586 = function() {
+    return handleError(function(arg0, arg1, arg2, arg3, arg4, arg5) {
+      getObject(arg0).open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
+    }, arguments);
+  };
+  imports.wbg.__wbg_process_dc0fbacc7c1c06f7 = function(arg0) {
+    const ret = getObject(arg0).process;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+  };
+  imports.wbg.__wbg_randomFillSync_ac0988aba3254290 = function() {
+    return handleError(function(arg0, arg1) {
+      getObject(arg0).randomFillSync(takeObject(arg1));
+    }, arguments);
+  };
+  imports.wbg.__wbg_require_60cc747a6bc5215a = function() {
+    return handleError(function() {
+      const ret = module.require;
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_responseText_7a33f62863958740 = function() {
+    return handleError(function(arg0, arg1) {
+      const ret = getObject(arg1).responseText;
+      var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+      var len1 = WASM_VECTOR_LEN;
+      getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+      getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+    }, arguments);
+  };
+  imports.wbg.__wbg_response_19d1d96c8fc76878 = function() {
+    return handleError(function(arg0) {
+      const ret = getObject(arg0).response;
+      return addHeapObject(ret);
+    }, arguments);
+  };
+  imports.wbg.__wbg_send_3accfe4b9b207011 = function() {
+    return handleError(function(arg0) {
+      getObject(arg0).send();
+    }, arguments);
+  };
+  imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+  };
+  imports.wbg.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+  };
+  imports.wbg.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_set_responseType_df7a5fa93f0dd4be = function(arg0, arg1) {
+    getObject(arg0).responseType = __wbindgen_enum_XmlHttpRequestResponseType[arg1];
+  };
+  imports.wbg.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
+  imports.wbg.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
+    const ret = typeof global === "undefined" ? null : global;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
+    const ret = typeof globalThis === "undefined" ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
+    const ret = typeof self === "undefined" ? null : self;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
+    const ret = typeof window === "undefined" ? null : window;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+  };
+  imports.wbg.__wbg_status_c547ab1614ba835e = function() {
+    return handleError(function(arg0) {
+      const ret = getObject(arg0).status;
+      return ret;
+    }, arguments);
+  };
+  imports.wbg.__wbg_subarray_845f2f5bce7d061a = function(arg0, arg1, arg2) {
+    const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_value_57b7b035e117f7ee = function(arg0) {
+    const ret = getObject(arg0).value;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_versions_c01dfd4722a88165 = function(arg0) {
+    const ret = getObject(arg0).versions;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbg_warn_6e567d0d926ff881 = function(arg0) {
+    console.warn(getObject(arg0));
+  };
+  imports.wbg.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+    const ret = arg0;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_cb9088102bce6b30 = function(arg0, arg1) {
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    const ret = arg0;
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
+    const ret = getObject(arg0);
+    return addHeapObject(ret);
+  };
+  imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+    takeObject(arg0);
+  };
+  return imports;
+}
+function __wbg_finalize_init(instance, module2) {
+  wasm = instance.exports;
+  __wbg_init.__wbindgen_wasm_module = module2;
+  cachedDataViewMemory0 = null;
+  cachedUint8ArrayMemory0 = null;
+  return wasm;
+}
+async function __wbg_init(module_or_path) {
+  if (wasm !== void 0) return wasm;
+  if (typeof module_or_path !== "undefined") {
+    if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+      ({ module_or_path } = module_or_path);
+    } else {
+      console.warn("using deprecated parameters for the initialization function; pass a single object instead");
+    }
+  }
+  if (typeof module_or_path === "undefined") {
+    module_or_path = new URL("udoc_bg.wasm", import.meta.url);
+  }
+  const imports = __wbg_get_imports();
+  if (typeof module_or_path === "string" || typeof Request === "function" && module_or_path instanceof Request || typeof URL === "function" && module_or_path instanceof URL) {
+    module_or_path = fetch(module_or_path);
+  }
+  const { instance, module: module2 } = await __wbg_load(await module_or_path, imports);
+  return __wbg_finalize_init(instance, module2);
+}
+var udoc_default = __wbg_init;
+
+// dist/src/worker/worker.js
+var udoc = null;
+var currentRequestId;
+self.onmessage = async (event) => {
+  const { _id, ...request } = event.data;
+  currentRequestId = _id;
+  try {
+    switch (request.type) {
+      case "init": {
+        await udoc_default(request.wasmUrl);
+        udoc = new UDoc();
+        respond({ type: "init", success: true });
+        break;
+      }
+      case "setLicense": {
+        ensureInitialized();
+        const result = udoc.set_license(request.license, request.domain);
+        respond({ type: "setLicense", success: true, result });
+        break;
+      }
+      case "getLicenseStatus": {
+        ensureInitialized();
+        const result = udoc.license_status();
+        respond({ type: "getLicenseStatus", success: true, result });
+        break;
+      }
+      case "loadPdf": {
+        ensureInitialized();
+        const documentId = udoc.load_pdf(request.bytes);
+        respond({ type: "loadPdf", success: true, documentId });
+        break;
+      }
+      case "loadImage": {
+        ensureInitialized();
+        const documentId = udoc.load_image(request.bytes);
+        respond({ type: "loadImage", success: true, documentId });
+        break;
+      }
+      case "loadPptx": {
+        ensureInitialized();
+        const documentId = udoc.load_pptx(request.bytes);
+        respond({ type: "loadPptx", success: true, documentId });
+        break;
+      }
+      case "unloadPdf": {
+        ensureInitialized();
+        const removed = udoc.remove_document(request.documentId);
+        respond({ type: "unloadPdf", success: true, removed });
+        break;
+      }
+      case "needsPassword": {
+        ensureInitialized();
+        const needsPassword = udoc.needs_password(request.documentId);
+        respond({ type: "needsPassword", success: true, needsPassword });
+        break;
+      }
+      case "authenticate": {
+        ensureInitialized();
+        const authenticated = udoc.authenticate(request.documentId, request.password);
+        respond({ type: "authenticate", success: true, authenticated });
+        break;
+      }
+      case "getPageCount": {
+        ensureInitialized();
+        const pageCount = udoc.page_count(request.documentId);
+        respond({ type: "getPageCount", success: true, pageCount });
+        break;
+      }
+      case "getPageInfo": {
+        ensureInitialized();
+        const info = udoc.page_info(request.documentId, request.pageIndex);
+        respond({ type: "getPageInfo", success: true, width: info.width, height: info.height, rotation: info.rotation });
+        break;
+      }
+      case "getAllPageInfo": {
+        ensureInitialized();
+        const pages = udoc.all_page_info(request.documentId);
+        respond({ type: "getAllPageInfo", success: true, pages });
+        break;
+      }
+      case "getPageLayout": {
+        ensureInitialized();
+        const layout = udoc.page_layout(request.documentId);
+        respond({ type: "getPageLayout", success: true, layout });
+        break;
+      }
+      case "renderPage": {
+        ensureInitialized();
+        const rgba = udoc.render_page_to_rgba(request.documentId, request.pageIndex, request.width, request.height);
+        respond({ type: "renderPage", success: true, rgba, width: request.width, height: request.height }, [rgba.buffer]);
+        break;
+      }
+      case "getOutline": {
+        ensureInitialized();
+        const outline = udoc.get_outline(request.documentId);
+        respond({ type: "getOutline", success: true, outline });
+        break;
+      }
+      case "getPageAnnotations": {
+        ensureInitialized();
+        const annotations = udoc.get_page_annotations(request.documentId, request.pageIndex);
+        respond({ type: "getPageAnnotations", success: true, annotations });
+        break;
+      }
+      case "getPageText": {
+        ensureInitialized();
+        const text = udoc.get_page_text(request.documentId, request.pageIndex);
+        respond({ type: "getPageText", success: true, text });
+        break;
+      }
+      case "getAllAnnotations": {
+        ensureInitialized();
+        const annotations = udoc.get_all_annotations(request.documentId);
+        respond({ type: "getAllAnnotations", success: true, annotations });
+        break;
+      }
+      case "pdfCompose": {
+        ensureInitialized();
+        const documentIds = udoc.pdf_compose(request.compositions, request.docIds);
+        respond({ type: "pdfCompose", success: true, documentIds });
+        break;
+      }
+      case "getBytes": {
+        ensureInitialized();
+        const bytes = udoc.get_bytes(request.documentId);
+        respond({ type: "getBytes", success: true, bytes }, [bytes.buffer]);
+        break;
+      }
+      case "pdfSplitByOutline": {
+        ensureInitialized();
+        const result = udoc.pdf_split_by_outline(request.documentId, request.maxLevel, request.splitMidPage);
+        respond({ type: "pdfSplitByOutline", success: true, result });
+        break;
+      }
+      case "pdfExtractImages": {
+        ensureInitialized();
+        const rawImages = udoc.pdf_extract_images(request.documentId, request.convertRawToPng);
+        const images = rawImages.map((img) => ({
+          ...img,
+          data: new Uint8Array(img.data)
+        }));
+        const transfers = images.map((img) => img.data.buffer);
+        respond({ type: "pdfExtractImages", success: true, images }, transfers);
+        break;
+      }
+      case "pdfExtractFonts": {
+        ensureInitialized();
+        const rawFonts = udoc.pdf_extract_fonts(request.documentId);
+        const fonts = rawFonts.map((font) => ({
+          ...font,
+          data: new Uint8Array(font.data)
+        }));
+        const transfers = fonts.map((font) => font.data.buffer);
+        respond({ type: "pdfExtractFonts", success: true, fonts }, transfers);
+        break;
+      }
+      case "pdfCompress": {
+        ensureInitialized();
+        const compressedBytes = udoc.pdf_compress(request.documentId);
+        respond({ type: "pdfCompress", success: true, bytes: compressedBytes }, [compressedBytes.buffer]);
+        break;
+      }
+      case "pdfDecompress": {
+        ensureInitialized();
+        const decompressedBytes = udoc.pdf_decompress(request.documentId);
+        respond({ type: "pdfDecompress", success: true, bytes: decompressedBytes }, [decompressedBytes.buffer]);
+        break;
+      }
+      case "getRequiredFonts": {
+        ensureInitialized();
+        const fonts = udoc.getRequiredFonts(request.documentId);
+        respond({ type: "getRequiredFonts", success: true, fonts });
+        break;
+      }
+      case "registerFont": {
+        ensureInitialized();
+        udoc.registerFont(request.documentId, request.typeface, request.bold, request.italic, request.bytes);
+        respond({ type: "registerFont", success: true });
+        break;
+      }
+      case "hasRegisteredFont": {
+        ensureInitialized();
+        const hasFont = udoc.hasRegisteredFont(request.documentId, request.typeface, request.bold, request.italic);
+        respond({ type: "hasRegisteredFont", success: true, hasFont });
+        break;
+      }
+      case "registeredFontCount": {
+        ensureInitialized();
+        const count = udoc.registeredFontCount(request.documentId);
+        respond({ type: "registeredFontCount", success: true, count });
+        break;
+      }
+      case "enableGoogleFonts": {
+        ensureInitialized();
+        udoc.enableGoogleFonts(request.documentId);
+        respond({ type: "enableGoogleFonts", success: true });
+        break;
+      }
+      default: {
+        const _exhaustive = request;
+        throw new Error(`Unknown request type: ${request.type}`);
+      }
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    respond({ type: request.type, success: false, error: errorMessage });
+  }
+};
+function ensureInitialized() {
+  if (!udoc) {
+    throw new Error("Worker not initialized. Call init first.");
+  }
+}
+function respond(response, transfer) {
+  const message = currentRequestId !== void 0 ? { ...response, _id: currentRequestId } : response;
+  if (transfer) {
+    self.postMessage(message, transfer);
+  } else {
+    self.postMessage(message);
+  }
 }
-//# sourceMappingURL=worker.js.map