From c9c3b33704fe7cc50cca997045a067c7c38b017b Mon Sep 17 00:00:00 2001
From: Vivek Gaddam <154349504+VivekGaddam@users.noreply.github.com>
Date: Wed, 22 Oct 2025 19:45:04 +0530
Subject: [PATCH] Word to pdf  (#88)

* feat(pdf-tools): add sanitize-pdf tool for comprehensive document cleaning

Implement a new PDF sanitization tool that allows users to remove various potentially sensitive elements from PDFs including metadata, annotations, JavaScript, embedded files, and more. The tool provides configurable options through checkboxes to selectively remove different types of content while preserving the core document structure.

Extract reusable utility functions from existing tools (remove-metadata, remove-annotations, flatten) to support the new sanitization feature. The tool handles edge cases gracefully and provides feedback when no changes are made.

* fix(sanitize-pdf): remove javascript actions, external links and font files

- Remove JavaScript actions from annotations and form fields
- Remove external links (URI, Launch, GoTo) from annotations
- Remove embedded font files while preserving font descriptors
- Add detailed error logging for each operation

* fix(sanitize-pdf): improve link removal and add named destinations cleanup

- Refactor link annotation removal logic to handle more action types (URI, Launch, GoTo, GoToR)
- Add cleanup of named destinations in catalog and names dictionary
- Improve error handling and logging throughout the sanitization process

* chore: update config files, icons and readme

- Update FUNDING.yml formatting
- Remove debug log in sanitize-pdf.ts
- Adjust test expectation for tool count
- Standardize dependabot.yml quotes
- Update tool icons in config
- Expand and reorganize README features list
- Fix markdown formatting in README

* Release v1.1.0

* without confilt

---------

Co-authored-by: abdullahalam123 <adullah.alam.tapadar2000@gmail.com>
---
 .github/FUNDING.yml                |    2 +-
 .github/dependabot.yml             |   14 +-
 README.md                          |   34 +-
 index.html                         |   22 +
 package.json                       |    2 +-
 src/js/config/pdf-tools.ts         |    1 +
 src/js/config/tools.ts             |   17 +-
 src/js/handlers/fileHandler.ts     |    6 +-
 src/js/logic/flatten.ts            |    8 +-
 src/js/logic/index.ts              |    6 +-
 src/js/logic/remove-annotations.ts |   71 +-
 src/js/logic/remove-metadata.ts    |   57 +-
 src/js/logic/sanitize-pdf.ts       |  587 +++++++++++++++
 src/js/logic/word-to-pdf.ts        |  243 +++---
 src/js/ui.ts                       |  102 ++-
 src/lib/zetajs/office_thread.js    |   83 +++
 src/lib/zetajs/zeta.js             | 1104 ++++++++++++++++++++++++++++
 src/lib/zetajs/zetaHelper.js       |  209 ++++++
 src/tests/pdf-tools.test.ts        |    2 +-
 src/types/globals.d.ts             |    8 +
 vite.config.ts                     |    8 +-
 21 files changed, 2371 insertions(+), 215 deletions(-)
 create mode 100644 src/js/logic/sanitize-pdf.ts
 create mode 100644 src/lib/zetajs/office_thread.js
 create mode 100644 src/lib/zetajs/zeta.js
 create mode 100644 src/lib/zetajs/zetaHelper.js

diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index f11c435f..5aba4924 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,2 +1,2 @@
 github: alam00000
-ko_fi: alio01
\ No newline at end of file
+ko_fi: alio01
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 8bf2edc7..b7f273d2 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,15 +1,15 @@
 version: 2
 updates:
-  - package-ecosystem: "npm"
-    directory: "/"
+  - package-ecosystem: 'npm'
+    directory: '/'
     schedule:
-      interval: "daily"
+      interval: 'daily'
     groups:
       npm-dependencies:
         patterns:
-          - "*"
+          - '*'
 
-  - package-ecosystem: "github-actions"
-    directory: "/"
+  - package-ecosystem: 'github-actions'
+    directory: '/'
     schedule:
-      interval: "daily"
+      interval: 'daily'
diff --git a/README.md b/README.md
index 4bd04a99..52fe5c60 100644
--- a/README.md
+++ b/README.md
@@ -26,16 +26,18 @@ BentoPDF offers a comprehensive suite of tools to handle all your PDF needs.
 
 ### Organize & Manage PDFs
 
-| Tool Name          | Description                                                                |
-| :----------------- | :------------------------------------------------------------------------- |
-| **Merge PDFs**     | Combine multiple PDF files into one.                                       |
-| **Split PDFs**     | Extract specific pages or divide a document into smaller files.            |
-| **Organize Pages** | Reorder, duplicate, or delete pages with a simple drag-and-drop interface. |
-| **Extract Pages**  | Save a specific range of pages as a new PDF.                               |
-| **Delete Pages**   | Remove unwanted pages from your document.                                  |
-| **Rotate PDF**     | Rotate individual or all pages in a document.                              |
-| **N-Up PDF**       | Combine multiple pages onto a single page.                                 |
-| **View PDF**       | A powerful, integrated PDF viewer.                                         |
+| Tool Name                 | Description                                                                |
+| :------------------------ | :------------------------------------------------------------------------- |
+| **Merge PDFs**            | Combine multiple PDF files into one.                                       |
+| **Split PDFs**            | Extract specific pages or divide a document into smaller files.            |
+| **Organize Pages**        | Reorder, duplicate, or delete pages with a simple drag-and-drop interface. |
+| **Extract Pages**         | Save a specific range of pages as a new PDF.                               |
+| **Delete Pages**          | Remove unwanted pages from your document.                                  |
+| **Rotate PDF**            | Rotate individual or all pages in a document.                              |
+| **N-Up PDF**              | Combine multiple pages onto a single page.                                 |
+| **View PDF**              | A powerful, integrated PDF viewer.                                         |
+| **Alternate & Mix pages** | Merge pages by alternating pages from each PDF.                            |
+| **Posterize PDF**         | Split a PDF into multiple smaller pages for print.                         |
 
 ### Edit & Modify PDFs
 
@@ -52,6 +54,7 @@ BentoPDF offers a comprehensive suite of tools to handle all your PDF needs.
 | **Fill Forms**         | Fill out PDF forms directly in your browser.                |
 | **Flatten PDF**        | Flatten form fields and annotations into static content.    |
 | **Remove Annotations** | Remove comments, highlights, and other annotations.         |
+| **Remove Blank Pages** | Auto detect and remove blank pages in a PDF.                |
 
 ### Convert to PDF
 
@@ -82,6 +85,8 @@ BentoPDF offers a comprehensive suite of tools to handle all your PDF needs.
 | **Redact Content**     | Permanently remove sensitive content from your PDFs.               |
 | **Edit Metadata**      | View and modify PDF metadata (author, title, keywords, etc.).      |
 | **Remove Metadata**    | Strip all metadata from your PDF for privacy.                      |
+| **Linearize PDF**      | Optimize PDF for fast web view.                                    |
+| **Sanitize PDF**       | Remove potentially unwanted or malicous files from PDF.            |
 
 ---
 
@@ -165,8 +170,8 @@ npm run release:minor
 npm run release:major
 ```
 
-````
 For detailed release instructions, see [RELEASE.md](RELEASE.md).
+
 ### 🚀 Development Setup
 
 #### Option 1: Run with npm
@@ -176,7 +181,7 @@ For detailed release instructions, see [RELEASE.md](RELEASE.md).
    ```bash
    git clone https://github.com/alam00000/bentopdf.git
    cd bentopdf
-````
+   ```
 
 2. **Install Dependencies**:
 
@@ -235,10 +240,8 @@ BentoPDF was originally built using **HTML**, **CSS**, and **vanilla JavaScript*
 
 - **HTML to PDF**: Convert HTML files or web pages into PDF documents.
 - **Markdown to PDF**: Enhanced support for converting `.md` files to PDF.
-- **Sanitize PDF**: Remove potentially malicious content like scripts from PDFs.
 - **Convert to PDF/A**: Convert PDFs to the PDF/A archival format.
 - **Edit PDF Content**: Directly edit text and other content within your PDF.
-- **Linearize PDF**: Optimize PDFs for fast web viewing.
 - **PDF to Office**: Converts PDF files into editable Word, Excel, and PowerPoint formats.
 - **Office to PDF**: Converts Word, Excel, and PowerPoint documents into optimized PDFs.
 
@@ -266,10 +269,11 @@ BentoPDF wouldn't be possible without the amazing open-source tools and librarie
 - **[PDFLib.js](https://pdf-lib.js.org/)** – For enabling powerful client-side PDF manipulation.
 - **[PDF.js](https://mozilla.github.io/pdf.js/)** – For the robust PDF rendering engine in the browser.
 - **[PDFKit](https://pdfkit.org/)** – For creating and editing PDFs with ease.
-- **[EmbedPDF](https://github.com/embedpdf/embed-pdf-viewer)** – For seamless PDF embedding in web pages.
+- **[EmbedPDF](https://github.com/embedpdf/embed-pdf-viewer)** – For seamless PDF editing in pure JS.
 - **[Cropper.js](https://fengyuanchen.github.io/cropperjs/)** – For intuitive image cropping functionality.
 - **[Vite](https://vitejs.dev/)** – For lightning-fast development and build tooling.
 - **[Tailwind CSS](https://tailwindcss.com/)** – For rapid, flexible, and beautiful UI styling.
+- **[qpdf](https://github.com/qpdf/qpdf)** and **[qpdf-wasm](https://github.com/neslinesli93/qpdf-wasm)**– A powerful command-line tool and library for inspecting, repairing, and transforming PDF file ported to wasm
 
 Your work inspires and empowers developers everywhere. Thank you for making open-source amazing!
 
diff --git a/index.html b/index.html
index 6ade8a4e..767cd74f 100644
--- a/index.html
+++ b/index.html
@@ -31,6 +31,7 @@
   </head>
 
   <body class="antialiased">
+    <canvas id="qtcanvas" style="display: none;"></canvas>
     <nav class="bg-gray-800 border-b border-gray-700 sticky top-0 z-30">
       <div class="container mx-auto px-4">
         <div class="flex justify-between items-center h-16">
@@ -937,7 +938,28 @@
       </div>
     </footer>
 
+    <script>
+        window.sofficeLoaded = false;
+
+        var Module = {
+            canvas: document.getElementById('qtcanvas'),
+            uno_scripts: ["zeta.js", "office_thread.js"],
+            locateFile(path, prefix) {
+                if (path.endsWith('.wasm') || path.endsWith('.data') || path.endsWith('.js') || path.endsWith('.metadata')) {
+                    return `/public/static/${path}`;
+                }
+                return path;
+            },
+            onRuntimeInitialized() {
+                window.sofficeLoaded = true;
+                console.log("✅ LibreOffice WASM cargado y listo.");
+            },
+            arguments: ['--headless']
+        };
+    </script>
+    <script src="/public/static/soffice.js"></script>
     <script type="module" src="src/js/main.ts"></script>
     <script type="module" src="src/js/mobileMenu.ts"></script>
   </body>
 </html>
+</html>
diff --git a/package.json b/package.json
index 9e254856..582df8c1 100644
--- a/package.json
+++ b/package.json
@@ -1,7 +1,7 @@
 {
   "name": "bento-pdf",
   "private": true,
-  "version": "1.0.2",
+  "version": "1.1.0",
   "license": "Apache-2.0",
   "type": "module",
   "scripts": {
diff --git a/src/js/config/pdf-tools.ts b/src/js/config/pdf-tools.ts
index 574b64f8..56d0cd32 100644
--- a/src/js/config/pdf-tools.ts
+++ b/src/js/config/pdf-tools.ts
@@ -38,6 +38,7 @@ export const singlePdfLoadTools = [
   'posterize',
   'remove-blank-pages',
   'add-attachments',
+  'sanitize-pdf',
 ];
 
 export const simpleTools = [
diff --git a/src/js/config/tools.ts b/src/js/config/tools.ts
index b5bb6285..afb709b6 100644
--- a/src/js/config/tools.ts
+++ b/src/js/config/tools.ts
@@ -204,7 +204,12 @@ export const categories = [
       },
       // { id: 'md-to-pdf', name: 'Markdown to PDF', icon: 'file-text', subtitle: 'Convert a Markdown file into a PDF.' },
       // { id: 'scan-to-pdf', name: 'Scan to PDF', icon: 'camera', subtitle: 'Use your camera to create a scanned PDF.' },
-      // { id: 'word-to-pdf', name: 'Word to PDF', icon: 'file-text', subtitle: 'Convert .docx documents to PDF.' },
+      {
+        id: 'word-to-pdf',
+        name: 'Word to PDF',
+        icon: 'file-text',
+        subtitle: 'Convert .docx documents to PDF.',
+      },
     ],
   },
   {
@@ -369,7 +374,7 @@ export const categories = [
       {
         id: 'posterize',
         name: 'Posterize PDF',
-        icon: 'layout-grid',
+        icon: 'notepad-text-dashed',
         subtitle: 'Split a large page into multiple smaller pages.',
       },
     ],
@@ -392,7 +397,7 @@ export const categories = [
       {
         id: 'linearize',
         name: 'Linearize PDF',
-        icon: 'zap',
+        icon: 'gauge',
         subtitle: 'Optimize PDF for fast web viewing.',
       },
       {
@@ -412,6 +417,12 @@ export const categories = [
         icon: 'lock',
         subtitle: 'Add a password to protect your PDF.',
       },
+      {
+        id: 'sanitize-pdf',
+        name: 'Sanitize PDF',
+        icon: 'brush-cleaning',
+        subtitle: 'Remove metadata, annotations, scripts, and more.',
+      },
       {
         id: 'decrypt',
         name: 'Decrypt PDF',
diff --git a/src/js/handlers/fileHandler.ts b/src/js/handlers/fileHandler.ts
index 9d6f2508..3c044137 100644
--- a/src/js/handlers/fileHandler.ts
+++ b/src/js/handlers/fileHandler.ts
@@ -269,9 +269,9 @@ async function handleSinglePdfUpload(toolId, file) {
             if ((child as Element).nodeType !== 1) continue;
 
             let key = (child as Element).tagName;
-            const elementChildren = Array.from((child as Element).children).filter(
-              (c) => c.nodeType === 1
-            );
+            const elementChildren = Array.from(
+              (child as Element).children
+            ).filter((c) => c.nodeType === 1);
 
             if (key === 'rdf:li') {
               appendXmpNodes(child, ulElement, indentLevel);
diff --git a/src/js/logic/flatten.ts b/src/js/logic/flatten.ts
index 16e4c804..17f58edc 100644
--- a/src/js/logic/flatten.ts
+++ b/src/js/logic/flatten.ts
@@ -2,6 +2,11 @@ import { showLoader, hideLoader, showAlert } from '../ui.js';
 import { downloadFile } from '../utils/helpers.js';
 import { state } from '../state.js';
 
+export function flattenFormsInDoc(pdfDoc) {
+  const form = pdfDoc.getForm();
+  form.flatten();
+}
+
 export async function flatten() {
   if (!state.pdfDoc) {
     showAlert('Error', 'PDF not loaded.');
@@ -9,8 +14,7 @@ export async function flatten() {
   }
   showLoader('Flattening PDF...');
   try {
-    const form = state.pdfDoc.getForm();
-    form.flatten();
+    flattenFormsInDoc(state.pdfDoc);
 
     const flattenedBytes = await state.pdfDoc.save();
     downloadFile(
diff --git a/src/js/logic/index.ts b/src/js/logic/index.ts
index 4ba504b9..bf3c3bcb 100644
--- a/src/js/logic/index.ts
+++ b/src/js/logic/index.ts
@@ -47,7 +47,7 @@ import { changeBackgroundColor } from './change-background-color.js';
 import { changeTextColor, setupTextColorTool } from './change-text-color.js';
 import { setupCompareTool } from './compare-pdfs.js';
 import { setupOcrTool } from './ocr-pdf.js';
-import { wordToPdf } from './word-to-pdf.js';
+import { setupWordToPdfTool } from './word-to-pdf.js';
 import { applyAndSaveSignatures, setupSignTool } from './sign-pdf.js';
 import {
   removeAnnotations,
@@ -63,6 +63,7 @@ import {
 import { alternateMerge, setupAlternateMergeTool } from './alternate-merge.js';
 import { linearizePdf } from './linearize.js';
 import { addAttachments, setupAddAttachmentsTool } from './add-attachments.js';
+import { sanitizePdf } from './sanitize-pdf.js';
 
 export const toolLogic = {
   merge: { process: merge, setup: setupMergeTool },
@@ -113,7 +114,7 @@ export const toolLogic = {
   'change-text-color': { process: changeTextColor, setup: setupTextColorTool },
   'compare-pdfs': { setup: setupCompareTool },
   'ocr-pdf': { setup: setupOcrTool },
-  'word-to-pdf': wordToPdf,
+  'word-to-pdf': { process: setupWordToPdfTool, setup: setupWordToPdfTool },
   'sign-pdf': { process: applyAndSaveSignatures, setup: setupSignTool },
   'remove-annotations': {
     process: removeAnnotations,
@@ -135,4 +136,5 @@ export const toolLogic = {
     process: addAttachments,
     setup: setupAddAttachmentsTool,
   },
+  'sanitize-pdf': sanitizePdf,
 };
diff --git a/src/js/logic/remove-annotations.ts b/src/js/logic/remove-annotations.ts
index 5aa425e8..e079f8f6 100644
--- a/src/js/logic/remove-annotations.ts
+++ b/src/js/logic/remove-annotations.ts
@@ -28,6 +28,48 @@ export function setupRemoveAnnotationsTool() {
   });
 }
 
+export function removeAnnotationsFromDoc(
+  pdfDoc,
+  pageIndices = null,
+  annotationTypes = null
+) {
+  const pages = pdfDoc.getPages();
+  const targetPages =
+    pageIndices || Array.from({ length: pages.length }, (_, i) => i);
+
+  for (const pageIndex of targetPages) {
+    const page = pages[pageIndex];
+    const annotRefs = page.node.Annots()?.asArray() || [];
+
+    if (!annotationTypes) {
+      if (annotRefs.length > 0) {
+        page.node.delete(PDFName.of('Annots'));
+      }
+    } else {
+      const annotsToKeep = [];
+
+      for (const ref of annotRefs) {
+        const annot = pdfDoc.context.lookup(ref);
+        const subtype = annot
+          .get(PDFName.of('Subtype'))
+          ?.toString()
+          .substring(1);
+
+        if (!subtype || !annotationTypes.has(subtype)) {
+          annotsToKeep.push(ref);
+        }
+      }
+
+      if (annotsToKeep.length > 0) {
+        const newAnnotsArray = pdfDoc.context.obj(annotsToKeep);
+        page.node.set(PDFName.of('Annots'), newAnnotsArray);
+      } else {
+        page.node.delete(PDFName.of('Annots'));
+      }
+    }
+  }
+}
+
 export async function removeAnnotations() {
   showLoader('Removing annotations...');
   try {
@@ -80,34 +122,7 @@ export async function removeAnnotations() {
     if (typesToRemove.size === 0)
       throw new Error('Please select at least one annotation type to remove.');
 
-    const pages = state.pdfDoc.getPages();
-
-    for (const pageIndex of targetPageIndices) {
-      const page = pages[pageIndex];
-      const annotRefs = page.node.Annots()?.asArray() || [];
-
-      const annotsToKeep = [];
-
-      for (const ref of annotRefs) {
-        const annot = state.pdfDoc.context.lookup(ref);
-        const subtype = annot
-          .get(PDFName.of('Subtype'))
-          ?.toString()
-          .substring(1);
-
-        // If the subtype is NOT in the list to remove, add it to our new array
-        if (!subtype || !typesToRemove.has(subtype)) {
-          annotsToKeep.push(ref);
-        }
-      }
-
-      if (annotsToKeep.length > 0) {
-        const newAnnotsArray = state.pdfDoc.context.obj(annotsToKeep);
-        page.node.set(PDFName.of('Annots'), newAnnotsArray);
-      } else {
-        page.node.delete(PDFName.of('Annots'));
-      }
-    }
+    removeAnnotationsFromDoc(state.pdfDoc, targetPageIndices, typesToRemove);
 
     const newPdfBytes = await state.pdfDoc.save();
     downloadFile(
diff --git a/src/js/logic/remove-metadata.ts b/src/js/logic/remove-metadata.ts
index a4f140fb..3fbbc4ec 100644
--- a/src/js/logic/remove-metadata.ts
+++ b/src/js/logic/remove-metadata.ts
@@ -1,23 +1,54 @@
 import { showLoader, hideLoader, showAlert } from '../ui.js';
 import { downloadFile } from '../utils/helpers.js';
 import { state } from '../state.js';
+import { PDFName } from 'pdf-lib';
+
+export function removeMetadataFromDoc(pdfDoc) {
+  const infoDict = pdfDoc.getInfoDict();
+  const allKeys = infoDict.keys();
+  allKeys.forEach((key: any) => {
+    infoDict.delete(key);
+  });
+
+  pdfDoc.setTitle('');
+  pdfDoc.setAuthor('');
+  pdfDoc.setSubject('');
+  pdfDoc.setKeywords([]);
+  pdfDoc.setCreator('');
+  pdfDoc.setProducer('');
+
+  try {
+    const catalogDict = pdfDoc.catalog.dict;
+    if (catalogDict.has(PDFName.of('Metadata'))) {
+      catalogDict.delete(PDFName.of('Metadata'));
+    }
+  } catch (e) {
+    console.warn('Could not remove XMP metadata:', e.message);
+  }
+
+  try {
+    const context = pdfDoc.context;
+    if (context.trailerInfo) {
+      delete context.trailerInfo.ID;
+    }
+  } catch (e) {
+    console.warn('Could not remove document IDs:', e.message);
+  }
+
+  try {
+    const catalogDict = pdfDoc.catalog.dict;
+    if (catalogDict.has(PDFName.of('PieceInfo'))) {
+      catalogDict.delete(PDFName.of('PieceInfo'));
+    }
+  } catch (e) {
+    console.warn('Could not remove PieceInfo:', e.message);
+  }
+}
 
 export async function removeMetadata() {
   showLoader('Removing all metadata...');
   try {
-    const infoDict = state.pdfDoc.getInfoDict();
-
-    const allKeys = infoDict.keys();
-    allKeys.forEach((key: any) => {
-      infoDict.delete(key);
-    });
-
-    state.pdfDoc.setTitle('');
-    state.pdfDoc.setAuthor('');
-    state.pdfDoc.setSubject('');
-    state.pdfDoc.setKeywords([]);
-    state.pdfDoc.setCreator('');
-    state.pdfDoc.setProducer('');
+    removeMetadataFromDoc(state.pdfDoc);
 
     const newPdfBytes = await state.pdfDoc.save();
     downloadFile(
diff --git a/src/js/logic/sanitize-pdf.ts b/src/js/logic/sanitize-pdf.ts
new file mode 100644
index 00000000..b1a0eca5
--- /dev/null
+++ b/src/js/logic/sanitize-pdf.ts
@@ -0,0 +1,587 @@
+import { showLoader, hideLoader, showAlert } from '../ui.js';
+import { downloadFile } from '../utils/helpers.js';
+import { state } from '../state.js';
+import { removeMetadataFromDoc } from './remove-metadata.js';
+import { removeAnnotationsFromDoc } from './remove-annotations.js';
+import { flattenFormsInDoc } from './flatten.js';
+import { PDFName } from 'pdf-lib';
+
+export async function sanitizePdf() {
+  if (!state.pdfDoc) {
+    showAlert('Error', 'No PDF document loaded.');
+    return;
+  }
+
+  showLoader('Sanitizing PDF...');
+  try {
+    const pdfDoc = state.pdfDoc;
+
+    const shouldFlattenForms = (
+      document.getElementById('flatten-forms') as HTMLInputElement
+    ).checked;
+    const shouldRemoveMetadata = (
+      document.getElementById('remove-metadata') as HTMLInputElement
+    ).checked;
+    const shouldRemoveAnnotations = (
+      document.getElementById('remove-annotations') as HTMLInputElement
+    ).checked;
+    const shouldRemoveJavascript = (
+      document.getElementById('remove-javascript') as HTMLInputElement
+    ).checked;
+    const shouldRemoveEmbeddedFiles = (
+      document.getElementById('remove-embedded-files') as HTMLInputElement
+    ).checked;
+    const shouldRemoveLayers = (
+      document.getElementById('remove-layers') as HTMLInputElement
+    ).checked;
+    const shouldRemoveLinks = (
+      document.getElementById('remove-links') as HTMLInputElement
+    ).checked;
+    const shouldRemoveStructureTree = (
+      document.getElementById('remove-structure-tree') as HTMLInputElement
+    ).checked;
+    const shouldRemoveMarkInfo = (
+      document.getElementById('remove-markinfo') as HTMLInputElement
+    ).checked;
+    const shouldRemoveFonts = (
+      document.getElementById('remove-fonts') as HTMLInputElement
+    ).checked;
+
+    let changesMade = false;
+
+    if (shouldFlattenForms) {
+      try {
+        flattenFormsInDoc(pdfDoc);
+        changesMade = true;
+      } catch (e) {
+        console.warn(`Could not flatten forms: ${e.message}`);
+        try {
+          const catalogDict = pdfDoc.catalog.dict;
+          if (catalogDict.has(PDFName.of('AcroForm'))) {
+            catalogDict.delete(PDFName.of('AcroForm'));
+            changesMade = true;
+          }
+        } catch (removeError) {
+          console.warn('Could not remove AcroForm:', removeError.message);
+        }
+      }
+    }
+
+    if (shouldRemoveMetadata) {
+      removeMetadataFromDoc(pdfDoc);
+      changesMade = true;
+    }
+
+    if (shouldRemoveAnnotations) {
+      removeAnnotationsFromDoc(pdfDoc);
+      changesMade = true;
+    }
+
+    if (shouldRemoveJavascript) {
+      try {
+        if (pdfDoc.javaScripts && pdfDoc.javaScripts.length > 0) {
+          pdfDoc.javaScripts = [];
+          changesMade = true;
+        }
+
+        const catalogDict = pdfDoc.catalog.dict;
+
+        const namesRef = catalogDict.get(PDFName.of('Names'));
+        if (namesRef) {
+          try {
+            const namesDict = pdfDoc.context.lookup(namesRef);
+            if (namesDict.has(PDFName.of('JavaScript'))) {
+              namesDict.delete(PDFName.of('JavaScript'));
+              changesMade = true;
+            }
+          } catch (e) {
+            console.warn('Could not access Names/JavaScript:', e.message);
+          }
+        }
+
+        if (catalogDict.has(PDFName.of('OpenAction'))) {
+          catalogDict.delete(PDFName.of('OpenAction'));
+          changesMade = true;
+        }
+
+        if (catalogDict.has(PDFName.of('AA'))) {
+          catalogDict.delete(PDFName.of('AA'));
+          changesMade = true;
+        }
+
+        const pages = pdfDoc.getPages();
+        for (const page of pages) {
+          try {
+            const pageDict = page.node;
+
+            if (pageDict.has(PDFName.of('AA'))) {
+              pageDict.delete(PDFName.of('AA'));
+              changesMade = true;
+            }
+
+            const annotRefs = pageDict.Annots()?.asArray() || [];
+            for (const annotRef of annotRefs) {
+              try {
+                const annot = pdfDoc.context.lookup(annotRef);
+
+                if (annot.has(PDFName.of('A'))) {
+                  const actionRef = annot.get(PDFName.of('A'));
+                  try {
+                    const actionDict = pdfDoc.context.lookup(actionRef);
+                    const actionType = actionDict
+                      .get(PDFName.of('S'))
+                      ?.toString()
+                      .substring(1);
+
+                    if (actionType === 'JavaScript') {
+                      annot.delete(PDFName.of('A'));
+                      changesMade = true;
+                    }
+                  } catch (e) {
+                    console.warn('Could not read action:', e.message);
+                  }
+                }
+
+                if (annot.has(PDFName.of('AA'))) {
+                  annot.delete(PDFName.of('AA'));
+                  changesMade = true;
+                }
+              } catch (e) {
+                console.warn('Could not process annotation for JS:', e.message);
+              }
+            }
+          } catch (e) {
+            console.warn('Could not remove page actions:', e.message);
+          }
+        }
+
+        try {
+          const acroFormRef = catalogDict.get(PDFName.of('AcroForm'));
+          if (acroFormRef) {
+            const acroFormDict = pdfDoc.context.lookup(acroFormRef);
+            const fieldsRef = acroFormDict.get(PDFName.of('Fields'));
+
+            if (fieldsRef) {
+              const fieldsArray = pdfDoc.context.lookup(fieldsRef);
+              const fields = fieldsArray.asArray();
+
+              for (const fieldRef of fields) {
+                try {
+                  const field = pdfDoc.context.lookup(fieldRef);
+
+                  if (field.has(PDFName.of('A'))) {
+                    field.delete(PDFName.of('A'));
+                    changesMade = true;
+                  }
+
+                  if (field.has(PDFName.of('AA'))) {
+                    field.delete(PDFName.of('AA'));
+                    changesMade = true;
+                  }
+                } catch (e) {
+                  console.warn('Could not process field for JS:', e.message);
+                }
+              }
+            }
+          }
+        } catch (e) {
+          console.warn('Could not process form fields for JS:', e.message);
+        }
+      } catch (e) {
+        console.warn(`Could not remove JavaScript: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveEmbeddedFiles) {
+      try {
+        const catalogDict = pdfDoc.catalog.dict;
+
+        const namesRef = catalogDict.get(PDFName.of('Names'));
+        if (namesRef) {
+          try {
+            const namesDict = pdfDoc.context.lookup(namesRef);
+            if (namesDict.has(PDFName.of('EmbeddedFiles'))) {
+              namesDict.delete(PDFName.of('EmbeddedFiles'));
+              changesMade = true;
+            }
+          } catch (e) {
+            console.warn('Could not access Names/EmbeddedFiles:', e.message);
+          }
+        }
+
+        if (catalogDict.has(PDFName.of('EmbeddedFiles'))) {
+          catalogDict.delete(PDFName.of('EmbeddedFiles'));
+          changesMade = true;
+        }
+
+        const pages = pdfDoc.getPages();
+        for (const page of pages) {
+          try {
+            const annotRefs = page.node.Annots()?.asArray() || [];
+            const annotsToKeep = [];
+
+            for (const ref of annotRefs) {
+              try {
+                const annot = pdfDoc.context.lookup(ref);
+                const subtype = annot
+                  .get(PDFName.of('Subtype'))
+                  ?.toString()
+                  .substring(1);
+
+                if (subtype !== 'FileAttachment') {
+                  annotsToKeep.push(ref);
+                } else {
+                  changesMade = true;
+                }
+              } catch (e) {
+                annotsToKeep.push(ref);
+              }
+            }
+
+            if (annotsToKeep.length !== annotRefs.length) {
+              if (annotsToKeep.length > 0) {
+                const newAnnotsArray = pdfDoc.context.obj(annotsToKeep);
+                page.node.set(PDFName.of('Annots'), newAnnotsArray);
+              } else {
+                page.node.delete(PDFName.of('Annots'));
+              }
+            }
+          } catch (pageError) {
+            console.warn(
+              `Could not process page for attachments: ${pageError.message}`
+            );
+          }
+        }
+
+        if (pdfDoc.embeddedFiles && pdfDoc.embeddedFiles.length > 0) {
+          pdfDoc.embeddedFiles = [];
+          changesMade = true;
+        }
+
+        if (catalogDict.has(PDFName.of('Collection'))) {
+          catalogDict.delete(PDFName.of('Collection'));
+          changesMade = true;
+        }
+      } catch (e) {
+        console.warn(`Could not remove embedded files: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveLayers) {
+      try {
+        const catalogDict = pdfDoc.catalog.dict;
+
+        if (catalogDict.has(PDFName.of('OCProperties'))) {
+          catalogDict.delete(PDFName.of('OCProperties'));
+          changesMade = true;
+        }
+
+        const pages = pdfDoc.getPages();
+        for (const page of pages) {
+          try {
+            const pageDict = page.node;
+
+            if (pageDict.has(PDFName.of('OCProperties'))) {
+              pageDict.delete(PDFName.of('OCProperties'));
+              changesMade = true;
+            }
+
+            const resourcesRef = pageDict.get(PDFName.of('Resources'));
+            if (resourcesRef) {
+              try {
+                const resourcesDict = pdfDoc.context.lookup(resourcesRef);
+                if (resourcesDict.has(PDFName.of('Properties'))) {
+                  resourcesDict.delete(PDFName.of('Properties'));
+                  changesMade = true;
+                }
+              } catch (e) {
+                console.warn('Could not access Resources:', e.message);
+              }
+            }
+          } catch (e) {
+            console.warn('Could not remove page layers:', e.message);
+          }
+        }
+      } catch (e) {
+        console.warn(`Could not remove layers: ${e.message}`);
+      }
+    }
+
+    // TODO:@ALAM
+    // Currently if the links are embedded in a stream they can't be removed
+    // Find a way to remove them from the stream
+    if (shouldRemoveLinks) {
+      try {
+        const pages = pdfDoc.getPages();
+
+        for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
+          try {
+            const page = pages[pageIndex];
+            const pageDict = page.node;
+
+            const annotsRef = pageDict.get(PDFName.of('Annots'));
+            if (!annotsRef) continue;
+
+            const annotsArray = pdfDoc.context.lookup(annotsRef);
+            const annotRefs = annotsArray.asArray();
+
+            if (annotRefs.length === 0) continue;
+
+            const annotsToKeep = [];
+            let linksRemoved = 0;
+
+            for (const ref of annotRefs) {
+              try {
+                const annot = pdfDoc.context.lookup(ref);
+                const subtype = annot
+                  .get(PDFName.of('Subtype'))
+                  ?.toString()
+                  .substring(1);
+
+                let isLink = false;
+
+                if (subtype === 'Link') {
+                  isLink = true;
+                  linksRemoved++;
+                } else {
+                  const actionRef = annot.get(PDFName.of('A'));
+                  if (actionRef) {
+                    try {
+                      const actionDict = pdfDoc.context.lookup(actionRef);
+                      const actionType = actionDict
+                        .get(PDFName.of('S'))
+                        ?.toString()
+                        .substring(1);
+
+                      if (
+                        actionType === 'URI' ||
+                        actionType === 'Launch' ||
+                        actionType === 'GoTo' ||
+                        actionType === 'GoToR'
+                      ) {
+                        isLink = true;
+                        linksRemoved++;
+                      }
+                    } catch (e) {
+                      console.warn('Could not read action:', e.message);
+                    }
+                  }
+
+                  const dest = annot.get(PDFName.of('Dest'));
+                  if (dest && !isLink) {
+                    isLink = true;
+                    linksRemoved++;
+                  }
+                }
+
+                if (!isLink) {
+                  annotsToKeep.push(ref);
+                }
+              } catch (e) {
+                console.warn('Could not process annotation:', e.message);
+                annotsToKeep.push(ref);
+              }
+            }
+
+            if (linksRemoved > 0) {
+              if (annotsToKeep.length > 0) {
+                const newAnnotsArray = pdfDoc.context.obj(annotsToKeep);
+                pageDict.set(PDFName.of('Annots'), newAnnotsArray);
+              } else {
+                pageDict.delete(PDFName.of('Annots'));
+              }
+              changesMade = true;
+            }
+          } catch (pageError) {
+            console.warn(
+              `Could not process page ${pageIndex + 1} for links: ${pageError.message}`
+            );
+          }
+        }
+
+        try {
+          const catalogDict = pdfDoc.catalog.dict;
+          const namesRef = catalogDict.get(PDFName.of('Names'));
+          if (namesRef) {
+            try {
+              const namesDict = pdfDoc.context.lookup(namesRef);
+              if (namesDict.has(PDFName.of('Dests'))) {
+                namesDict.delete(PDFName.of('Dests'));
+                changesMade = true;
+              }
+            } catch (e) {
+              console.warn('Could not access Names/Dests:', e.message);
+            }
+          }
+
+          if (catalogDict.has(PDFName.of('Dests'))) {
+            catalogDict.delete(PDFName.of('Dests'));
+            changesMade = true;
+          }
+        } catch (e) {
+          console.warn('Could not remove named destinations:', e.message);
+        }
+      } catch (e) {
+        console.warn(`Could not remove links: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveStructureTree) {
+      try {
+        const catalogDict = pdfDoc.catalog.dict;
+
+        if (catalogDict.has(PDFName.of('StructTreeRoot'))) {
+          catalogDict.delete(PDFName.of('StructTreeRoot'));
+          changesMade = true;
+        }
+
+        const pages = pdfDoc.getPages();
+        for (const page of pages) {
+          try {
+            const pageDict = page.node;
+            if (pageDict.has(PDFName.of('StructParents'))) {
+              pageDict.delete(PDFName.of('StructParents'));
+              changesMade = true;
+            }
+          } catch (e) {
+            console.warn('Could not remove page StructParents:', e.message);
+          }
+        }
+
+        if (catalogDict.has(PDFName.of('ParentTree'))) {
+          catalogDict.delete(PDFName.of('ParentTree'));
+          changesMade = true;
+        }
+      } catch (e) {
+        console.warn(`Could not remove structure tree: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveMarkInfo) {
+      try {
+        const catalogDict = pdfDoc.catalog.dict;
+
+        if (catalogDict.has(PDFName.of('MarkInfo'))) {
+          catalogDict.delete(PDFName.of('MarkInfo'));
+          changesMade = true;
+        }
+
+        if (catalogDict.has(PDFName.of('Marked'))) {
+          catalogDict.delete(PDFName.of('Marked'));
+          changesMade = true;
+        }
+      } catch (e) {
+        console.warn(`Could not remove MarkInfo: ${e.message}`);
+      }
+    }
+
+    if (shouldRemoveFonts) {
+      try {
+        const pages = pdfDoc.getPages();
+
+        for (let pageIndex = 0; pageIndex < pages.length; pageIndex++) {
+          try {
+            const page = pages[pageIndex];
+            const pageDict = page.node;
+            const resourcesRef = pageDict.get(PDFName.of('Resources'));
+
+            if (resourcesRef) {
+              try {
+                const resourcesDict = pdfDoc.context.lookup(resourcesRef);
+
+                if (resourcesDict.has(PDFName.of('Font'))) {
+                  const fontRef = resourcesDict.get(PDFName.of('Font'));
+
+                  try {
+                    const fontDict = pdfDoc.context.lookup(fontRef);
+                    const fontKeys = fontDict.keys();
+
+                    for (const fontKey of fontKeys) {
+                      try {
+                        const specificFontRef = fontDict.get(fontKey);
+                        const specificFont =
+                          pdfDoc.context.lookup(specificFontRef);
+
+                        if (specificFont.has(PDFName.of('FontDescriptor'))) {
+                          const descriptorRef = specificFont.get(
+                            PDFName.of('FontDescriptor')
+                          );
+                          const descriptor =
+                            pdfDoc.context.lookup(descriptorRef);
+
+                          const fontFileKeys = [
+                            'FontFile',
+                            'FontFile2',
+                            'FontFile3',
+                          ];
+                          for (const key of fontFileKeys) {
+                            if (descriptor.has(PDFName.of(key))) {
+                              descriptor.delete(PDFName.of(key));
+                              changesMade = true;
+                            }
+                          }
+                        }
+
+                        // Users/Developers: Uncomment this if you can delete the entire font entry -- might break the rendering though
+                        // fontDict.delete(fontKey);
+                        // changesMade = true;
+                      } catch (e) {
+                        console.warn(
+                          `Could not process font ${fontKey}:`,
+                          e.message
+                        );
+                      }
+                    }
+                  } catch (e) {
+                    console.warn(
+                      'Could not access font dictionary:',
+                      e.message
+                    );
+                  }
+                }
+              } catch (e) {
+                console.warn(
+                  'Could not access Resources for fonts:',
+                  e.message
+                );
+              }
+            }
+          } catch (e) {
+            console.warn(
+              `Could not remove fonts from page ${pageIndex + 1}:`,
+              e.message
+            );
+          }
+        }
+
+        if (pdfDoc.fonts && pdfDoc.fonts.length > 0) {
+          pdfDoc.fonts = [];
+          changesMade = true;
+        }
+      } catch (e) {
+        console.warn(`Could not remove fonts: ${e.message}`);
+      }
+    }
+
+    if (!changesMade) {
+      showAlert(
+        'No Changes',
+        'No items were selected for removal or none were found in the PDF.'
+      );
+      hideLoader();
+      return;
+    }
+
+    const sanitizedPdfBytes = await pdfDoc.save();
+    downloadFile(
+      new Blob([sanitizedPdfBytes], { type: 'application/pdf' }),
+      'sanitized.pdf'
+    );
+    showAlert('Success', 'PDF has been sanitized and downloaded.');
+  } catch (e) {
+    console.error('Sanitization Error:', e);
+    showAlert('Error', `An error occurred during sanitization: ${e.message}`);
+  } finally {
+    hideLoader();
+  }
+}
diff --git a/src/js/logic/word-to-pdf.ts b/src/js/logic/word-to-pdf.ts
index 6439ab29..2a67ebc2 100644
--- a/src/js/logic/word-to-pdf.ts
+++ b/src/js/logic/word-to-pdf.ts
@@ -1,140 +1,137 @@
-// NOTE: This is a work in progress and does not work correctly as of yet
-import { showLoader, hideLoader, showAlert } from '../ui.js';
-import { readFileAsArrayBuffer } from '../utils/helpers.js';
-import { state } from '../state.js';
+import { ZetaHelperMain } from '../../lib/zetajs/zetaHelper';
 
-export async function wordToPdf() {
-  const file = state.files[0];
-  if (!file) {
-    showAlert('No File', 'Please upload a .docx file first.');
+async function waitForSofficeLoaded(timeout = 10000): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+    function check() {
+      if ((window as any).sofficeLoaded) {
+        resolve();
+      } else if (Date.now() - start > timeout) {
+        reject('Timeout waiting for soffice.wasm to load.');
+      } else {
+        requestAnimationFrame(check);
+      }
+    }
+    check();
+  });
+}
+
+async function waitForElements(ids: string[], timeout = 5000): Promise<Record<string, HTMLElement>> {
+  return new Promise((resolve, reject) => {
+    const start = Date.now();
+
+    function check() {
+      const elements: Record<string, HTMLElement> = {};
+      let allFound = true;
+
+      for (const id of ids) {
+        const el = document.getElementById(id);
+        if (!el) allFound = false;
+        else elements[id] = el;
+      }
+
+      if (allFound) resolve(elements);
+      else if (Date.now() - start > timeout) reject('Timeout waiting for DOM elements: ' + ids.join(', '));
+      else requestAnimationFrame(check);
+    }
+
+    check();
+  });
+}
+
+export async function setupWordToPdfTool() {
+  let elements: Record<string, HTMLElement>;
+  try {
+    await waitForSofficeLoaded();
+    elements = await waitForElements([
+      'qtcanvas',
+      'file-input',
+      'download',
+      'frame',
+      'word-to-pdf-output'
+    ]);
+  } catch (err) {
+    console.error(err);
     return;
   }
 
-  showLoader('Preparing preview...');
+  const {
+    qtcanvas: canvas,
+    'file-input': input,
+    download: downloadCheckbox,
+    frame: iframe,
+    'word-to-pdf-output': wordToPdfOutput
+  } = elements;
 
-  try {
-    const mammothOptions = {
-      // @ts-expect-error TS(2304) FIXME: Cannot find name 'mammoth'.
-      convertImage: mammoth.images.inline((element: any) => {
-        return element.read('base64').then((imageBuffer: any) => {
-          return {
-            src: `data:${element.contentType};base64,${imageBuffer}`,
-          };
-        });
-      }),
-    };
-    const arrayBuffer = await readFileAsArrayBuffer(file);
-    // @ts-expect-error TS(2304) FIXME: Cannot find name 'mammoth'.
-    const { value: html } = await mammoth.convertToHtml(
-      { arrayBuffer },
-      mammothOptions
-    );
+  const zHM = new ZetaHelperMain('/static/office_thread.js', {
+    threadJsType: 'module',
+    wasmPkg: 'url:/static/'
+  });
 
-    // Get references to our modal elements from index.html
-    const previewModal = document.getElementById('preview-modal');
-    const previewContent = document.getElementById('preview-content');
-    const downloadBtn = document.getElementById('preview-download-btn');
-    const closeBtn = document.getElementById('preview-close-btn');
+  // Assign thrPort.onmessage immediately
+  zHM.thrPort.onmessage = (e: MessageEvent) => {
+    const data = e.data;
+    switch (data.cmd) {
+      case 'converted':
+        try { (window as any).FS.unlink(data.from); } catch {}
+        const fileData = (window as any).FS.readFile(data.to);
+        const blob = new Blob([fileData], { type: 'application/pdf' });
+        const url = URL.createObjectURL(blob);
 
-    const styledHtml = `
-            <style>
-                #preview-content { font-family: 'Times New Roman', Times, serif; font-size: 12pt; line-height: 1.5; color: black; }
-                #preview-content table { border-collapse: collapse; width: 100%; }
-                #preview-content td, #preview-content th { border: 1px solid #dddddd; text-align: left; padding: 8px; }
-                #preview-content img { max-width: 100%; height: auto; }
-                #preview-content a { color: #0000ee; text-decoration: underline; }
-            </style>
-            ${html}
-        `;
-    previewContent.innerHTML = styledHtml;
+        // Show PDF in iframe
+        (iframe as HTMLIFrameElement).src = url;
+        wordToPdfOutput.classList.remove('hidden');
 
-    const marginDiv = document.createElement('div');
-    marginDiv.style.height = '100px';
-    previewContent.appendChild(marginDiv);
+        // Download if checkbox is checked
+        if ((downloadCheckbox as HTMLInputElement).checked) {
+          const a = document.createElement('a');
+          a.href = url;
+          a.download = `${data.name || 'output'}.pdf`;
+          a.click();
+        }
 
-    const images = previewContent.querySelectorAll('img');
-    const imagePromises = Array.from(images).map((img) => {
-      return new Promise((resolve) => {
-        // @ts-expect-error TS(2794) FIXME: Expected 1 arguments, but got 0. Did you forget to... Remove this comment to see the full error message
-        if (img.complete) resolve();
-        else img.onload = resolve;
-      });
-    });
-    await Promise.all(imagePromises);
+        try { (window as any).FS.unlink(data.to); } catch {}
+        (input as HTMLInputElement).disabled = false;
+        break;
 
-    previewModal.classList.remove('hidden');
-    hideLoader();
+      case 'start':
+        // Internal message, can ignore
+        break;
 
-    const downloadHandler = async () => {
-      showLoader('Generating High-Quality PDF...');
+      default:
+        console.warn('Unknown command from WASM:', data.cmd);
+    }
+  };
 
-      // @ts-expect-error TS(2339) FIXME: Property 'jspdf' does not exist on type 'Window & ... Remove this comment to see the full error message
-      const { jsPDF } = window.jspdf;
-      const doc = new jsPDF({
-        orientation: 'p',
-        unit: 'pt',
-        format: 'letter',
-      });
+  // Wait for ZetaHelper to initialize
+  await new Promise<void>(resolve => zHM.start(resolve));
 
-      await doc.html(previewContent, {
-        callback: function (doc: any) {
-          const links = previewContent.querySelectorAll('a');
-          const pageHeight = doc.internal.pageSize.getHeight();
-          const containerRect = previewContent.getBoundingClientRect(); // Get container's position
+  // Handle file selection
+  (input as HTMLInputElement).onchange = async () => {
+    const inputEl = input as HTMLInputElement;
+    if (!inputEl.files || inputEl.files.length === 0) {
+      console.error('No file selected.');
+      return;
+    }
 
-          links.forEach((link) => {
-            if (!link.href) return;
+    inputEl.disabled = true;
+    const file = inputEl.files[0];
+    let name = file.name;
+    let from = '/tmp/input';
+    const n = name.lastIndexOf('.');
+    if (n > 0) {
+      from += name.substring(n);
+      name = name.substring(0, n);
+    }
 
-            const linkRect = link.getBoundingClientRect();
+    const arrayBuffer = await file.arrayBuffer();
+    if (!(window as any).FS) {
+      console.error('FS not initialized yet.');
+      inputEl.disabled = false;
+      return;
+    }
 
-            // Calculate position relative to the preview container's top-left
-            const relativeX = linkRect.left - containerRect.left;
-            const relativeY = linkRect.top - containerRect.top;
-
-            const pageNum = Math.floor(relativeY / pageHeight) + 1;
-            const yOnPage = relativeY % pageHeight;
-
-            doc.setPage(pageNum);
-            try {
-              doc.link(
-                relativeX + 45,
-                yOnPage + 45,
-                linkRect.width,
-                linkRect.height,
-                { url: link.href }
-              );
-            } catch (e) {
-              console.warn('Could not add link:', link.href, e);
-            }
-          });
-
-          const outputFileName = `${file.name.replace(/\.[^/.]+$/, '')}.pdf`;
-          doc.save(outputFileName);
-          hideLoader();
-        },
-        autoPaging: 'slice',
-        x: 45,
-        y: 45,
-        width: 522,
-        windowWidth: previewContent.scrollWidth,
-      });
-    };
-
-    const closeHandler = () => {
-      previewModal.classList.add('hidden');
-      previewContent.innerHTML = '';
-      downloadBtn.removeEventListener('click', downloadHandler);
-      closeBtn.removeEventListener('click', closeHandler);
-    };
-
-    downloadBtn.addEventListener('click', downloadHandler);
-    closeBtn.addEventListener('click', closeHandler);
-  } catch (e) {
-    console.error(e);
-    hideLoader();
-    showAlert(
-      'Preview Error',
-      `Could not generate a preview. The file may be corrupt or contain unsupported features. Error: ${e.message}`
-    );
-  }
+    (window as any).FS.writeFile(from, new Uint8Array(arrayBuffer));
+    zHM.thrPort.postMessage({ cmd: 'convert', name, from, to: '/tmp/output' });
+  };
 }
diff --git a/src/js/ui.ts b/src/js/ui.ts
index d85ff7a2..c53d62da 100644
--- a/src/js/ui.ts
+++ b/src/js/ui.ts
@@ -1477,23 +1477,27 @@ export const toolTemplates = {
 `,
 
   'word-to-pdf': () => `
-        <h2 class="text-2xl font-bold text-white mb-4">Word to PDF Converter</h2>
-        <p class="mb-6 text-gray-400">Upload a .docx file to convert it into a high-quality PDF with selectable text. Complex layouts may not be perfectly preserved.</p>
-        
-        <div id="file-input-wrapper">
-             <div class="relative flex flex-col items-center justify-center w-full h-48 border-2 border-dashed border-gray-600 rounded-xl cursor-pointer bg-gray-900 hover:bg-gray-700">
-                <div class="flex flex-col items-center justify-center pt-5 pb-6">
-                    <i data-lucide="file-text" class="w-10 h-10 mb-3 text-gray-400"></i>
-                    <p class="mb-2 text-sm text-gray-400"><span class="font-semibold">Click to select a file</span> or drag and drop</p>
-                    <p class="text-xs text-gray-500">A single .docx file</p>
-                </div>
-                <input id="file-input" type="file" class="absolute top-0 left-0 w-full h-full opacity-0 cursor-pointer" accept=".docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document">
+<div id="word-to-pdf-output" >
+    <canvas id="qtcanvas" class="hidden"></canvas>
+    <iframe id="frame" class="w-full h-[600px] mt-4 border border-gray-600 rounded-lg"></iframe>
+    <input type="checkbox" id="download" class="hidden" checked /> <!-- optional -->
+    
+    <div id="file-input-wrapper">
+         <div class="relative flex flex-col items-center justify-center w-full h-48 border-2 border-dashed border-gray-600 rounded-xl cursor-pointer bg-gray-900 hover:bg-gray-700">
+            <div class="flex flex-col items-center justify-center pt-5 pb-6">
+                <i data-lucide="file-text" class="w-10 h-10 mb-3 text-gray-400"></i>
+                <p class="mb-2 text-sm text-gray-400"><span class="font-semibold">Click to select a file</span> or drag and drop</p>
+                <p class="text-xs text-gray-500">A single .docx file</p>
             </div>
+            <input id="file-input" type="file" class="absolute top-0 left-0 w-full h-full opacity-0 cursor-pointer" accept=".docx,application/vnd.openxmlformats-officedocument.wordprocessingml.document">
         </div>
-        
-        <div id="file-display-area" class="mt-4 space-y-2"></div>
-        <button id="process-btn" class="btn-gradient w-full mt-6" disabled>Preview & Convert</button>
-    `,
+    </div>
+    
+    <div id="file-display-area" class="mt-4 space-y-2"></div>
+    <button id="process-btn" class="btn-gradient w-full mt-6" disabled>Preview & Convert</button>
+</div>
+`
+,
 
   'sign-pdf': () => `
     <h2 class="text-2xl font-bold text-white mb-4">Sign PDF</h2>
@@ -1910,4 +1914,72 @@ export const toolTemplates = {
       <button id="process-btn" class="hidden btn-gradient w-full mt-6" disabled>Embed Files & Download</button>
     </div>
   `,
+
+  'sanitize-pdf': () => `
+    <h2 class="text-2xl font-bold text-white mb-4">Sanitize PDF</h2>
+    <p class="mb-6 text-gray-400">Remove potentially sensitive or unnecessary information from your PDF before sharing. Select the items you want to remove.</p>
+    ${createFileInputHTML()}
+    <div id="file-display-area" class="mt-4 space-y-2"></div>
+
+    <div id="sanitize-pdf-options" class="hidden mt-6 space-y-4 p-4 bg-gray-900 border border-gray-700 rounded-lg">
+        <h3 class="text-lg font-semibold text-white mb-3">Sanitization Options</h3>
+    <div>
+            <strong class="font-semibold text-yellow-200">Note:</strong>
+            Removing <code class="bg-gray-700 px-1 rounded text-white">Embedded Fonts</code> may break text rendering! Text may not display correctly or at all. Only use if you're sure the PDF viewer has substitute fonts.
+    </div>
+        <div class="mb-4">
+            <h4 class="text-sm font-semibold text-gray-400 mb-2">Essential Security</h4>
+            <div class="grid grid-cols-1 sm:grid-cols-2 gap-3">
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="flatten-forms" name="sanitizeOption" value="flatten-forms" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Flatten Form Fields</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-metadata" name="sanitizeOption" value="metadata" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove All Metadata</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-annotations" name="sanitizeOption" value="annotations" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Annotations</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-javascript" name="sanitizeOption" value="javascript" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove JavaScript</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-embedded-files" name="sanitizeOption" value="embeddedFiles" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Embedded Files</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-layers" name="sanitizeOption" value="layers" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Layers (OCG)</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-links" name="sanitizeOption" value="links" checked class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove External Links</span>
+                </label>
+            </div>
+        </div>
+
+        <div>
+            <h4 class="text-sm font-semibold text-gray-400 mb-2">Additional Options</h4>
+            <div class="grid grid-cols-1 sm:grid-cols-2 gap-3">
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-structure-tree" name="sanitizeOption" value="structure" class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Structure Tree</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-markinfo" name="sanitizeOption" value="markinfo" class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white">Remove Tagging Info</span>
+                </label>
+                <label class="flex items-center space-x-2 p-3 rounded-md bg-gray-800 hover:bg-gray-700 cursor-pointer">
+                    <input type="checkbox" id="remove-fonts" name="sanitizeOption" value="fonts" class="w-5 h-5 text-indigo-600 bg-gray-700 border-gray-600 rounded focus:ring-indigo-500">
+                    <span class="text-white text-sm">Remove Embedded Fonts</span>
+                </label>
+            </div>
+        </div>
+
+        <button id="process-btn" class="btn-gradient w-full mt-6">Sanitize PDF & Download</button>
+    </div>
+`,
 };
diff --git a/src/lib/zetajs/office_thread.js b/src/lib/zetajs/office_thread.js
new file mode 100644
index 00000000..c04109c5
--- /dev/null
+++ b/src/lib/zetajs/office_thread.js
@@ -0,0 +1,83 @@
+import { ZetaHelperMain } from '@zetajs/zetaHelper.js';
+
+// Elements
+const canvas = document.getElementById('qtcanvas');
+const input = document.getElementById('input');
+const fileButton = document.getElementById('file-button');
+const downloadCheckbox = document.getElementById('download');
+const iframe = document.getElementById('frame');
+
+const wasmPkg = 'url:./static/'; // adjust if needed
+
+const zHM = new ZetaHelperMain('./src/office_thread.js', {
+  threadJsType: 'module',
+  wasmPkg
+});
+
+zHM.start(() => {
+  // ✅ Assign onmessage handler immediately after start
+  zHM.thrPort.onmessage = (e) => {
+    switch (e.data.cmd) {
+      case 'converted':
+        try { window.FS.unlink(e.data.from); } catch {}
+        const data = window.FS.readFile(e.data.to);
+        const blob = new Blob([data], { type: 'application/pdf' });
+        const url = URL.createObjectURL(blob);
+
+        iframe.src = url;
+
+        if (downloadCheckbox.checked) {
+          const a = document.createElement('a');
+          a.href = url;
+          a.download = `${e.data.name || 'output'}.pdf`;
+          document.body.appendChild(a);
+          a.click();
+          a.remove();
+        }
+
+        try { window.FS.unlink(e.data.to); } catch {}
+        URL.revokeObjectURL(url);
+        break;
+
+      case 'start':
+        input.disabled = false;
+        fileButton.disabled = false;
+        break;
+
+      default:
+        console.warn('Unknown message command:', e.data.cmd);
+    }
+  };
+
+  // ✅ Assign fileButton click
+  fileButton.onclick = () => input.click();
+
+  // ✅ Assign input onchange
+  input.onchange = async () => {
+    input.disabled = true;
+    fileButton.disabled = true;
+
+    const file = input.files?.[0];
+    if (!file) return;
+
+    if (!window.FS) {
+      console.error('FS not initialized yet.');
+      input.disabled = false;
+      fileButton.disabled = false;
+      return;
+    }
+
+    let name = file.name;
+    let from = '/tmp/input';
+    const n = name.lastIndexOf('.');
+    if (n > 0) {
+      from += name.substring(n);
+      name = name.substring(0, n);
+    }
+
+    const arrayBuffer = await file.arrayBuffer();
+    window.FS.writeFile(from, new Uint8Array(arrayBuffer));
+
+    zHM.thrPort.postMessage({ cmd: 'convert', name, from, to: '/tmp/output' });
+  };
+});
diff --git a/src/lib/zetajs/zeta.js b/src/lib/zetajs/zeta.js
new file mode 100644
index 00000000..aeab34f1
--- /dev/null
+++ b/src/lib/zetajs/zeta.js
@@ -0,0 +1,1104 @@
+/* -*- Mode: JS; tab-width: 2; indent-tabs-mode: nil; js-indent-level: 2; fill-column: 100 -*- */
+// SPDX-License-Identifier: MIT
+
+'use strict';
+
+Module.zetajs = new Promise(function (resolve, reject) {
+  Module.zetajs$resolve = function() {
+    // A FinalizationRegistry for zetajs objects that own Embind objects that, in turn, should
+    // be .delete()'d (so that Embind doesn't print any "Embind found a leaked C++ instance"
+    // warnings for them); it is tied to Module so it doesn't itself get GC'ed early:
+    Module.uno$zetajs_deleteRegistry = new FinalizationRegistry(function(value) {
+      value.forEach((val) => val.delete());
+    });
+    const getProxyTarget = Symbol('getProxyTarget');
+    const keepAlive = Symbol('keepAlive');
+    function gcWrap(obj) {
+      // Embind has already registered obj at some FinalizationRegistry that prints the
+      // "Embind found a leaked C++ instance" warning, which we want to suppress; and if we
+      // registered obj itself also at our deleting FinalizationRegistry, the Embind one might
+      // fire first and still print the warning; so instead wrap obj in a Proxy and register
+      // that:
+      const proxy = new Proxy(obj, {});
+      Module.uno$zetajs_deleteRegistry.register(proxy, [obj]);
+      return proxy
+    }
+    function getEmbindSequenceCtor(componentType) {
+      let typename = componentType.toString();
+      let name = 'uno_Sequence';
+      let n = 1;
+      while (typename.startsWith('[]')) {
+        typename = typename.substr(2);
+        ++n;
+      }
+      if (n !== 1) {
+        name += n;
+      }
+      name += '_' + typename.replace(/ /g, '_').replace(/\./g, '$');
+      return Module[name];
+    };
+    function getTypeDescriptionManager() {
+      const ctx = Module.getUnoComponentContext();
+      const tdmAny = ctx.getValueByName(
+        '/singletons/com.sun.star.reflection.theTypeDescriptionManager');
+      ctx.delete();
+      const val = tdmAny.get();
+      tdmAny.delete();
+      const tdm = Module.uno.com.sun.star.container.XHierarchicalNameAccess.query(val);
+      val.delete();
+      return tdm;
+    };
+    function translateTypeDescription(td) {
+      switch (td.getTypeClass()) {
+      case Module.uno.com.sun.star.uno.TypeClass.VOID:
+        return Module.uno_Type.Void();
+      case Module.uno.com.sun.star.uno.TypeClass.BOOLEAN:
+        return Module.uno_Type.Boolean();
+      case Module.uno.com.sun.star.uno.TypeClass.BYTE:
+        return Module.uno_Type.Byte();
+      case Module.uno.com.sun.star.uno.TypeClass.SHORT:
+        return Module.uno_Type.Short();
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_SHORT:
+        return Module.uno_Type.UnsignedShort();
+      case Module.uno.com.sun.star.uno.TypeClass.LONG:
+        return Module.uno_Type.Long();
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_LONG:
+        return Module.uno_Type.UnsignedLong();
+      case Module.uno.com.sun.star.uno.TypeClass.HYPER:
+        return Module.uno_Type.Hyper();
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_HYPER:
+        return Module.uno_Type.UnsignedHyper();
+      case Module.uno.com.sun.star.uno.TypeClass.FLOAT:
+        return Module.uno_Type.Float();
+      case Module.uno.com.sun.star.uno.TypeClass.DOUBLE:
+        return Module.uno_Type.Double();
+      case Module.uno.com.sun.star.uno.TypeClass.CHAR:
+        return Module.uno_Type.Char();
+      case Module.uno.com.sun.star.uno.TypeClass.STRING:
+        return Module.uno_Type.String();
+      case Module.uno.com.sun.star.uno.TypeClass.TYPE:
+        return Module.uno_Type.Type();
+      case Module.uno.com.sun.star.uno.TypeClass.ANY:
+        return Module.uno_Type.Any();
+      case Module.uno.com.sun.star.uno.TypeClass.SEQUENCE:
+        {
+          const itd = Module.uno.com.sun.star.reflection.XIndirectTypeDescription.query(td);
+          const rtd = itd.getReferencedType();
+          itd.delete();
+          const type = translateTypeDescriptionAndDelete(rtd);
+          try {
+            return Module.uno_Type.Sequence(type);
+          } finally {
+            type.delete();
+          }
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.ENUM:
+        return Module.uno_Type.Enum(td.getName());
+      case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+        return Module.uno_Type.Struct(td.getName());
+      case Module.uno.com.sun.star.uno.TypeClass.EXCEPTION:
+        return Module.uno_Type.Exception(td.getName());
+      case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+        return Module.uno_Type.Interface(td.getName());
+      default:
+        throw new Error(
+          'bad type description ' + td.getName() + ' type class ' + td.getTypeClass());
+      }
+    };
+    function translateTypeDescriptionAndDelete(td) {
+      try {
+        return translateTypeDescription(td);
+      } finally {
+        td.delete();
+      }
+    }
+    function translateToEmbind(obj, type, toDelete) {
+      switch (type.getTypeClass()) {
+      case Module.uno.com.sun.star.uno.TypeClass.ANY:
+          {
+              const {any, owning} = translateToAny(obj, Module.uno_Type.Any());
+              if (owning) {
+                  toDelete.push(any);
+              }
+              return any;
+          }
+      case Module.uno.com.sun.star.uno.TypeClass.SEQUENCE:
+          if (Array.isArray(obj)) {
+              const ctype = type.getSequenceComponentType();
+              const seq = new (getEmbindSequenceCtor(ctype))(
+                  obj.length, Module.uno_Sequence.FromSize);
+              for (let i = 0; i !== obj.length; ++i) {
+                  seq.set(i, translateToEmbind(obj[i], ctype, toDelete));
+              }
+              ctype.delete();
+              toDelete.push(seq);
+              return seq;
+          }
+          break;
+      case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+      case Module.uno.com.sun.star.uno.TypeClass.EXCEPTION:
+          {
+              const val = {};
+              function walk(td) {
+                  const base = td.getBaseType();
+                  if (base !== null) {
+                      const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription
+                          .query(base);
+                      base.delete();
+                      walk(td);
+                      td.delete();
+                  }
+                  const types = td.getMemberTypes();
+                  const names = td.getMemberNames();
+                  for (let i = 0; i !== types.size(); ++i) {
+                      const name = names.get(i);
+                      const type = translateTypeDescriptionAndDelete(types.get(i));
+                      val[name] = translateToEmbind(obj[name], type, toDelete);
+                      type.delete();
+                  }
+                  types.delete();
+                  names.delete();
+              };
+              const tdm = getTypeDescriptionManager();
+              const tdAny = tdm.getByHierarchicalName(type.toString());
+              tdm.delete();
+              const ifc = tdAny.get();
+              tdAny.delete();
+              const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription.query(
+                  ifc);
+              ifc.delete();
+              walk(td);
+              td.delete();
+              return val;
+          }
+      case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+          if (obj !== null) {
+              const target = obj[getProxyTarget];
+              const handle = target === undefined ? obj : target;
+              if (handle instanceof Module.ClassHandle) {
+                  if (type.toString() === 'com.sun.star.uno.XInterface') {
+                      return handle;
+                  }
+                  const embindType = 'uno_Type_' + type.toString().replace(/\./g, '$');
+                  if (embindType === handle.$$.ptrType.registeredClass.name) {
+                      return handle;
+                  } else {
+                      const ifc = Module[embindType].query(handle);
+                      toDelete.push(ifc);
+                      return ifc;
+                  }
+              }
+          }
+          break;
+      }
+      return obj;
+    };
+    function translateToAny(obj, type) {
+      try {
+        let any;
+        let owning;
+        if (obj instanceof Module.uno_Any) {
+          any = obj;
+          owning = false;
+        } else {
+          let fromType;
+          let val;
+          if (type.getTypeClass() === Module.uno.com.sun.star.uno.TypeClass.ANY) {
+            fromType = getAnyType(obj);
+            if (fromType === undefined) {
+              throw new Error('bad UNO method call argument ' + obj);
+            }
+            val = fromAny(obj);
+          } else {
+            fromType = type;
+            val = obj;
+          }
+          const toDelete = [];
+          any = new Module.uno_Any(fromType, translateToEmbind(val, fromType, toDelete));
+          owning = true;
+          toDelete.forEach((val) => val.delete());
+        }
+        return {any, owning};
+      } finally {
+        type.delete();
+      }
+    };
+    function translateFromEmbind(val, type, precise, cleanUpVal) {
+      switch (type.getTypeClass()) {
+      case Module.uno.com.sun.star.uno.TypeClass.BOOLEAN:
+        return Boolean(val);
+      case Module.uno.com.sun.star.uno.TypeClass.TYPE:
+        return gcWrap(val);
+      case Module.uno.com.sun.star.uno.TypeClass.ANY:
+        {
+          const ty = gcWrap(val.getType());
+          let v;
+          try {
+            v = translateFromEmbind(val.get(), ty, precise, cleanUpVal);
+          } finally {
+            if (cleanUpVal) {
+              val.delete();
+            }
+          }
+          return precise ? new Any(ty, v) : v;
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.SEQUENCE:
+        {
+          const td = type.getSequenceComponentType();
+          const arr = [];
+          for (let i = 0; i !== val.size(); ++i) {
+            arr.push(translateFromEmbind(val.get(i), td, precise, cleanUpVal));
+          }
+          if (cleanUpVal) {
+            val.delete();
+          }
+          td.delete();
+          return arr;
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+      case Module.uno.com.sun.star.uno.TypeClass.EXCEPTION:
+        {
+          const obj = {
+            [Module.unoTagSymbol]: {
+              kind: type.getTypeClass()
+                == Module.uno.com.sun.star.uno.TypeClass.STRUCT
+                ? 'struct-instance' : 'exception-instance',
+              type: type.toString()
+            }
+          };
+          function walk(td) {
+            const base = td.getBaseType();
+            if (base !== null) {
+              const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription
+                .query(base);
+              base.delete();
+              walk(td);
+              td.delete();
+            }
+            const types = td.getMemberTypes();
+            const names = td.getMemberNames();
+            for (let i = 0; i !== types.size(); ++i) {
+              const name = names.get(i);
+              const td = translateTypeDescriptionAndDelete(types.get(i));
+              obj[name] = translateFromEmbind(val[name], td, precise, cleanUpVal);
+              td.delete();
+            }
+            types.delete();
+            names.delete();
+          };
+          const tdm = getTypeDescriptionManager();
+          const tdAny = tdm.getByHierarchicalName(type.toString());
+          tdm.delete();
+          const ifc = tdAny.get();
+          tdAny.delete();
+          const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription.query(
+            ifc);
+          ifc.delete();
+          walk(td);
+          td.delete();
+          return obj;
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+        return proxy(val);
+      default:
+        return val;
+      }
+    };
+    function translateFromAny(any, type, precise) {
+      if (type.getTypeClass() === Module.uno.com.sun.star.uno.TypeClass.ANY) {
+        return translateFromEmbind(any, type, precise, false);
+      } else {
+        const td = any.getType();
+        const val = translateFromEmbind(any.get(), td, precise, true);
+        td.delete();
+        return val;
+      }
+    };
+    function translateFromAnyAndDelete(any, type, precise) {
+      const val = translateFromAny(any, type, precise);
+      any.delete();
+      return val;
+    };
+    function proxy(unoObject) {
+      if (unoObject === null) {
+        return null;
+      }
+      const prox = {};
+      const toDelete = [unoObject];
+      Module.uno$zetajs_deleteRegistry.register(prox, toDelete);
+      prox[getProxyTarget] = unoObject;
+      prox.$precise = {[getProxyTarget]: unoObject, [keepAlive]: prox};
+      // css.script.XInvocation2::getInfo invents additional members (e.g., an attribute "Foo"
+      // if there is a method "getFoo"), so better determine the actual set of members via
+      // css.lang.XTypeProvider::getTypes:
+      const typeprov = Module.uno.com.sun.star.lang.XTypeProvider.query(unoObject);
+      if (typeprov !== null) {
+        const ty = Module.uno_Type.Interface('com.sun.star.uno.XInterface');
+        const arg = new Module.uno_Any(ty, unoObject);
+        ty.delete();
+        const args = new Module.uno_Sequence_any([arg]);
+        arg.delete();
+        const ctx = Module.getUnoComponentContext();
+        const serv = Module.uno.com.sun.star.script.Invocation.create(ctx);
+        ctx.delete();
+        const inst = serv.createInstanceWithArguments(args);
+        args.delete();
+        serv.delete();
+        const invoke = Module.uno.com.sun.star.script.XInvocation2.query(inst);
+        inst.delete();
+        toDelete.push(invoke);
+        function invokeMethod(name, args, precise) {
+          const info = invoke.getInfoForName(name, true);
+          try {
+            if (args.length != info.aParamTypes.size()) {
+              throw new Error(
+                'bad number of arguments in call to ' + name + ', expected ' +
+                  info.aParamTypes.size() + ' vs. actual ' + args.length);
+            }
+            const unoArgs = new Module.uno_Sequence_any(
+              info.aParamTypes.size(), Module.uno_Sequence.FromSize);
+            const deleteArgs = [];
+            for (let i = 0; i !== info.aParamTypes.size(); ++i) {
+              switch (info.aParamModes.get(i)) {
+              case Module.uno.com.sun.star.reflection.ParamMode.IN:
+                {
+                  const {any, owning} = translateToAny(
+                    args[i], info.aParamTypes.get(i));
+                  unoArgs.set(i, any);
+                  if (owning) {
+                    deleteArgs.push(any);
+                  }
+                  break;
+                }
+              case Module.uno.com.sun.star.reflection.ParamMode.INOUT:
+                {
+                  const {any, owning} = translateToAny(
+                    args[i].val, info.aParamTypes.get(i));
+                  unoArgs.set(i, any);
+                  if (owning) {
+                    deleteArgs.push(any);
+                  }
+                  break;
+                }
+              }
+            }
+            const outparamindex_out = new Module.uno_InOutParam_sequence_short;
+            const outparam_out = new Module.uno_InOutParam_sequence_any;
+            let ret;
+            try {
+              ret = invoke.invoke(name, unoArgs, outparamindex_out, outparam_out);
+            } catch (e) {
+              outparamindex_out.delete();
+              outparam_out.delete();
+              const exc = catchUnoException(e);
+              if (getAnyType(exc) ==
+                'com.sun.star.reflection.InvocationTargetException')
+              {
+                throwUnoException(exc.TargetException);
+              } else {
+                throwUnoException(exc);
+              }
+            } finally {
+              deleteArgs.forEach((arg) => arg.delete());
+              unoArgs.delete();
+            }
+            const outparamindex = outparamindex_out.val;
+            outparamindex_out.delete();
+            const outparam = outparam_out.val;
+            outparam_out.delete();
+            for (let i = 0; i !== outparamindex.size(); ++i) {
+              const j = outparamindex.get(i);
+              const ty = info.aParamTypes.get(j);
+              args[j].val = translateFromAnyAndDelete(outparam.get(i), ty, precise);
+              ty.delete();
+            }
+            outparamindex.delete();
+            outparam.delete();
+            return translateFromAnyAndDelete(ret, info.aType, precise);
+          } finally {
+            info.aType.delete();
+            info.aParamTypes.delete();
+            info.aParamModes.delete();
+          }
+        };
+        function invokeGetter(name, precise) {
+          const info = invoke.getInfoForName(name, true);
+          try {
+            const ret = invoke.getValue(name);
+            return translateFromAnyAndDelete(ret, info.aType, precise);
+          } finally {
+            info.aType.delete();
+            info.aParamTypes.delete();
+            info.aParamModes.delete();
+          }
+        };
+        function invokeSetter(name, value) {
+          const info = invoke.getInfoForName(name, true);
+          const deleteArgs = [];
+          const {any, owning} = translateToAny(value, info.aType);
+          if (owning) {
+            deleteArgs.push(any);
+          }
+          try {
+            invoke.setValue(name, any);
+          } finally {
+            // info.aType already deleted in translateToAny above
+            info.aParamTypes.delete();
+            info.aParamModes.delete();
+          }
+        };
+        prox.queryInterface = function() {
+            return invokeMethod('queryInterface', arguments, false); };
+        prox.$precise.queryInterface = function() {
+            return invokeMethod('queryInterface', arguments, true); };
+        const seen = {'com.sun.star.uno.XInterface': true};
+        function walk(td) {
+          const iname = td.getName();
+          if (!Object.hasOwn(seen, iname)) {
+            seen[iname] = true;
+            if (td.getTypeClass() !== Module.uno.com.sun.star.uno.TypeClass.INTERFACE) {
+              throw new Error('not a UNO interface type: ' + iname);
+            }
+            const itd = Module.uno.com.sun.star.reflection.XInterfaceTypeDescription2
+                .query(td);
+            const bases = itd.getBaseTypes();
+            for (let i = 0; i !== bases.size(); ++i) {
+              const base = bases.get(i);
+              walk(base);
+              base.delete();
+            }
+            bases.delete();
+            const mems = itd.getMembers();
+            for (let i = 0; i !== mems.size(); ++i) {
+              const mem = mems.get(i);
+              const name = mem.getMemberName();
+              const atd = Module.uno.com.sun.star.reflection
+                  .XInterfaceAttributeTypeDescription.query(mem);
+              mem.delete();
+              if (atd !== null) {
+                Object.defineProperty(prox, name, {
+                  enumerable: true,
+                  get() { return invokeGetter(name, false); },
+                  set: atd.isReadOnly()
+                    ? undefined
+                    : function(value) { return invokeSetter(name, value); }});
+                Object.defineProperty(prox.$precise, name, {
+                  enumerable: true,
+                  get() { return invokeGetter(name, true); },
+                  set: atd.isReadOnly()
+                    ? undefined
+                    : function(value) { return invokeSetter(name, value); }});
+                atd.delete();
+              } else {
+                prox[name] = function() { return invokeMethod(name, arguments, false); };
+                prox.$precise[name] = function() { return invokeMethod(name, arguments, true); };
+              }
+            }
+            itd.delete();
+            mems.delete();
+            if (iname === 'com.sun.star.container.XEnumeration') {
+              prox[Symbol.iterator] = function*() {
+                while (prox.hasMoreElements()) {
+                  yield prox.nextElement();
+                }
+              }
+              prox.$precise[Symbol.iterator] = function*() {
+                while (prox.$precise.hasMoreElements()) {
+                  yield prox.$precise.nextElement();
+                }
+              }
+            }
+          }
+        };
+        const tdm = getTypeDescriptionManager();
+        const types = typeprov.getTypes();
+        typeprov.delete();
+        for (let i = 0; i != types.size(); ++i) {
+          const ty = types.get(i);
+          const td = tdm.getByHierarchicalName(ty.toString());
+          ty.delete();
+          const ifc1 = td.get();
+          td.delete();
+          const ifc2 = Module.uno.com.sun.star.reflection.XTypeDescription.query(ifc1);
+          ifc1.delete();
+          walk(ifc2);
+          ifc2.delete();
+        }
+        tdm.delete();
+        types.delete();
+      }
+      return prox;
+    };
+    function singleton(name) {
+      return function(context) {
+        const any = context.getValueByName('/singletons/' + name);
+        if (getAnyType(any).getTypeClass() !==
+            Module.uno.com.sun.star.uno.TypeClass.INTERFACE
+          || any === null)
+        {
+          throwUnoException(
+            new uno.com.sun.star.uno.DeploymentException(
+              {Message: 'cannot get singeleton ' + name}));
+        }
+        return any.val;
+      };
+    };
+    function service(name, td) {
+      const obj = {};
+      const ctors = td.getConstructors();
+      for (let i = 0; i !== ctors.size(); ++i) {
+        const ctor = ctors.get(i);
+        if (ctor.isDefaultConstructor()) {
+          obj.create = function(context) {
+            const ifc = context.getServiceManager().createInstanceWithContext(
+              name, context);
+            if (ifc === null) {
+              throwUnoException(
+                new uno.com.sun.star.uno.DeploymentException(
+                  {Message:
+                   'cannot instantiate single-interface service ' + name}));
+            }
+            return ifc;
+          };
+        } else {
+          obj[ctor.getName()] = function() {
+            const context = arguments[0];
+            const args = [];
+            const params = ctor.getParameters();
+            for (let j = 0; j !== params.size(); ++j) {
+              const param = params.get(j);
+              if (param.isRestParameter()) {
+                for (; j + 1 < arguments.length; ++j) {
+                  args.push(arguments[j + 1]);
+                }
+                break;
+              } else {
+                let arg = arguments[j + 1];
+                const ty = param.getType();
+                if (ty.getTypeClass() !== Module.uno.com.sun.star.uno.TypeClass.ANY)
+                {
+                  arg = new Any(
+                    gcWrap(translateTypeDescriptionAndDelete(param.getType())),
+                    arg);
+                }
+                ty.delete();
+                args.push(arg);
+              }
+              param.delete();
+            }
+            params.delete();
+            const ifc = context.getServiceManager()
+                  .createInstanceWithArgumentsAndContext(name, args, context);
+            if (ifc === null) {
+              throwUnoException(
+                new uno.com.sun.star.uno.DeploymentException(
+                  {Message:
+                   'cannot instantiate single-interface service ' + name}));
+            }
+            return ifc;
+          };
+        }
+      }
+      ctors.delete();
+      return obj;
+    };
+    function defaultValue(type) {
+      switch (type.getTypeClass()) {
+      case Module.uno.com.sun.star.uno.TypeClass.BOOLEAN:
+        return false;
+      case Module.uno.com.sun.star.uno.TypeClass.BYTE:
+      case Module.uno.com.sun.star.uno.TypeClass.SHORT:
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_SHORT:
+      case Module.uno.com.sun.star.uno.TypeClass.LONG:
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_LONG:
+      case Module.uno.com.sun.star.uno.TypeClass.FLOAT:
+      case Module.uno.com.sun.star.uno.TypeClass.DOUBLE:
+        return 0;
+      case Module.uno.com.sun.star.uno.TypeClass.HYPER:
+      case Module.uno.com.sun.star.uno.TypeClass.UNSIGNED_HYPER:
+        return 0n;
+      case Module.uno.com.sun.star.uno.TypeClass.CHAR:
+        return '\0';
+      case Module.uno.com.sun.star.uno.TypeClass.STRING:
+        return '';
+      case Module.uno.com.sun.star.uno.TypeClass.TYPE:
+        return Module.uno_Type.Void();
+      case Module.uno.com.sun.star.uno.TypeClass.ANY:
+        return undefined;
+      case Module.uno.com.sun.star.uno.TypeClass.SEQUENCE:
+        return [];
+      case Module.uno.com.sun.star.uno.TypeClass.ENUM:
+        {
+          const tdm = getTypeDescriptionManager();
+          const tdAny = tdm.getByHierarchicalName(type.toString());
+          tdm.delete();
+          const ifc = tdAny.get();
+          tdAny.delete();
+          const td = Module.uno.com.sun.star.reflection.XEnumTypeDescription.query(ifc);
+          ifc.delete();
+          const names = td.getEnumNames();
+          td.delete();
+          const first = names.get(0);
+          names.delete();
+          return Module['uno_Type_' + type.toString().replace(/\./g, '$')][first];
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+        {
+          //TODO: Make val an instanceof the corresponding struct constructor function:
+          const tdm = getTypeDescriptionManager();
+          const tdAny = tdm.getByHierarchicalName(type.toString());
+          tdm.delete();
+          const ifc = tdAny.get();
+          tdAny.delete();
+          const td = Module.uno.com.sun.star.reflection.XTypeDescription.query(ifc);
+          ifc.delete();
+          const members = {};
+          computeMembers(td, members);
+          td.delete();
+          const val = {};
+          populate(val, [], members);
+          return val;
+        }
+      case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+        return null;
+      default:
+        throw new Error('bad member type ' + type);
+      }
+    }
+    function TypeArgumentIndex(index) { this.index = index; };
+    function computeMembers(type, obj) {
+      const td = Module.uno.com.sun.star.reflection.XCompoundTypeDescription.query(type);
+      const base = td.getBaseType();
+      if (base !== null) {
+        computeMembers(base, obj);
+        base.delete();
+      }
+      const types = td.getMemberTypes();
+      const names = td.getMemberNames();
+      td.delete();
+      for (let i = 0; i !== types.size(); ++i) {
+        const memtype = types.get(i);
+        let val;
+        if (memtype.getTypeClass() === Module.uno.com.sun.star.uno.TypeClass.UNKNOWN) {
+          const paramName = memtype.getName();
+          const std = Module.uno.com.sun.star.reflection.XStructTypeDescription.query(
+            type);
+          const params = std.getTypeParameters();
+          std.delete();
+          let index = 0;
+          for (; index !== params.size(); ++index) {
+            if (params.get(index) === paramName) {
+              break;
+            }
+          }
+          params.delete();
+          val = new TypeArgumentIndex(index);
+        } else {
+          const type = translateTypeDescription(memtype);
+          val = defaultValue(type);
+          type.delete();
+        }
+        memtype.delete();
+        obj[names.get(i)] = val;
+      }
+      types.delete();
+      names.delete();
+    };
+    function populate(obj, types, members, values) {
+      for (let i in members) {
+        let val;
+        if (values !== undefined && i in values) {
+          val = values[i];
+        } else {
+          val = members[i];
+          if (val instanceof TypeArgumentIndex) {
+            val = defaultValue(types[val.index]);
+          }
+        }
+        obj[i] = val;
+      }
+    };
+    function instantiationName(templateName, types) {
+      let name = templateName + '<';
+      for (let i = 0; i !== types.length; ++i) {
+        if (i !== 0) {
+          name += ',';
+        }
+        name += types[i];
+      }
+      return name + '>';
+    }
+    function unoidlProxy(path, embindObject) {
+      return new Proxy({}, {
+        get(target, prop) {
+          if (!Object.hasOwn(target, prop)) {
+            const name = path + '.' + prop;
+            const tdm = getTypeDescriptionManager();
+            const tdAny = tdm.getByHierarchicalName(name);
+            tdm.delete();
+            const ifc = tdAny.get();
+            tdAny.delete();
+            const td = Module.uno.com.sun.star.reflection.XTypeDescription.query(ifc);
+            ifc.delete();
+            switch (td.getTypeClass()) {
+            case Module.uno.com.sun.star.uno.TypeClass.ENUM:
+              target[prop] = embindObject[prop];
+              target[prop][Module.unoTagSymbol] = {kind: 'enum', type: name};
+              break;
+            case Module.uno.com.sun.star.uno.TypeClass.STRUCT:
+              {
+                const members = {};
+                computeMembers(td, members);
+                const std = Module.uno.com.sun.star.reflection
+                  .XStructTypeDescription.query(td);
+                const params = std.getTypeParameters();
+                std.delete();
+                const paramCount = params.size();
+                params.delete();
+                if (paramCount === 0) {
+                  target[prop] = function(values) {
+                    populate(this, [], members, values);
+                    this[Module.unoTagSymbol] = {
+                      kind: 'struct-instance', type: name};
+                  };
+                } else {
+                  target[prop] = function(types, values) {
+                    if (types.length !== paramCount) {
+                      throw new Error(
+                        'bad number of type arguments in call to ' + name +
+                          ', expected ' + paramCount + ' vs. actual ' +
+                          types.length);
+                    }
+                    populate(this, types, members, values);
+                    this[Module.unoTagSymbol] = {
+                      kind: 'struct-instance',
+                      type: instantiationName(name, types)};
+                  };
+                }
+                target[prop][Module.unoTagSymbol] = {kind: 'struct', type: name};
+                break;
+              }
+            case Module.uno.com.sun.star.uno.TypeClass.EXCEPTION:
+              {
+                const members = {};
+                computeMembers(td, members);
+                target[prop] = function(values) {
+                  populate(this, [], members, values);
+                  this[Module.unoTagSymbol] = {
+                    kind: 'exception-instance', type: name};
+                };
+                target[prop][Module.unoTagSymbol] = {kind: 'exception', type: name};
+                break;
+              }
+            case Module.uno.com.sun.star.uno.TypeClass.INTERFACE:
+              target[prop] = {[Module.unoTagSymbol]: {kind: 'interface', type: name}};
+              break;
+            case Module.uno.com.sun.star.uno.TypeClass.MODULE:
+              target[prop] = unoidlProxy(name, embindObject[prop]);
+              break;
+            case Module.uno.com.sun.star.uno.TypeClass.SINGLETON:
+              target[prop] = singleton(name);
+              break;
+            case Module.uno.com.sun.star.uno.TypeClass.SERVICE:
+              {
+                const std = Module.uno.com.sun.star.reflection
+                  .XServiceTypeDescription2.query(td);
+                if (std.isSingleInterfaceBased()) {
+                  target[prop] = service(name, std);
+                }
+                std.delete();
+                break;
+              }
+            case Module.uno.com.sun.star.uno.TypeClass.CONSTANTS:
+              target[prop] = embindObject[prop];
+              break;
+            }
+            td.delete();
+          }
+          return target[prop];
+        }
+      });
+    };
+    function Any(type, val) {
+      this.type = type;
+      this.val = val;
+    };
+    function getAnyType(val) {
+      switch (typeof val) {
+      case 'undefined':
+        return gcWrap(Module.uno_Type.Void());
+      case 'boolean':
+        return gcWrap(Module.uno_Type.Boolean());
+      case 'number':
+        return gcWrap(
+          Number.isInteger(val) && val >= -0x80000000 && val < 0x80000000
+            ? Module.uno_Type.Long()
+            : Number.isInteger(val) && val >= 0 && val < 0x100000000
+            ? Module.uno_Type.UnsignedLong()
+            : Module.uno_Type.Double());
+      case 'bigint':
+        return gcWrap(
+          val < 0x8000000000000000n
+            ? Module.uno_Type.Hyper() : Module.uno_Type.UnsignedHyper());
+      case 'string':
+        return gcWrap(Module.uno_Type.String());
+      case 'object':
+        if (val === null || Object.hasOwn(val, getProxyTarget)) {
+          return gcWrap(Module.uno_Type.Interface('com.sun.star.uno.XInterface'));
+        } else if (val instanceof Module.uno_Type) {
+          return gcWrap(Module.uno_Type.Type());
+        } else if (val instanceof Any) {
+          return val.type;
+        } else if (val instanceof Array) {
+          const t = Module.uno_Type.Any();
+          try {
+            return gcWrap(Module.uno_Type.Sequence(t));
+          } finally {
+            t.delete();
+          }
+        } else {
+          const tag = val[Module.unoTagSymbol];
+          if (tag !== undefined) {
+            if (tag.kind === 'enumerator') {
+              return gcWrap(Module.uno_Type.Enum(tag.type));
+            } else if (tag.kind === 'struct-instance') {
+              return gcWrap(Module.uno_Type.Struct(tag.type));
+            } else if (tag.kind === 'exception-instance') {
+              return gcWrap(Module.uno_Type.Exception(tag.type));
+            }
+          }
+        }
+        // fallthrough
+      default:
+        return undefined;
+      }
+    };
+    function fromAny(val) { return val instanceof Any ? val.val : val; };
+    function throwUnoException(exception) {
+      const type = gcWrap(Module.uno_Type.Exception(exception[Module.unoTagSymbol].type));
+      const toDelete = [];
+      const val = translateToEmbind(exception, type, toDelete);
+      Module.throwUnoException(type, val, toDelete);
+    };
+    function catchUnoException(exception) {
+        const td = Module.uno_Type.Any();
+        try {
+          return translateFromAnyAndDelete(Module.catchUnoException(exception), td);
+        } finally {
+          td.delete();
+        }
+    };
+    const uno = new Proxy({}, {
+      get(target, prop) {
+        if (!Object.hasOwn(target, prop)) {
+          const tdm = getTypeDescriptionManager();
+          const td = tdm.getByHierarchicalName(prop);
+          tdm.delete();
+          td.delete();
+          target[prop] = unoidlProxy(prop, Module.uno[prop]);
+        }
+        return target[prop];
+      }
+    });
+    const zetajs = {
+      type: {
+        void: gcWrap(Module.uno_Type.Void()),
+        boolean: gcWrap(Module.uno_Type.Boolean()),
+        byte: gcWrap(Module.uno_Type.Byte()),
+        short: gcWrap(Module.uno_Type.Short()),
+        unsigned_short: gcWrap(Module.uno_Type.UnsignedShort()),
+        long: gcWrap(Module.uno_Type.Long()),
+        unsigned_long: gcWrap(Module.uno_Type.UnsignedLong()),
+        hyper: gcWrap(Module.uno_Type.Hyper()),
+        unsigned_hyper: gcWrap(Module.uno_Type.UnsignedHyper()),
+        float: gcWrap(Module.uno_Type.Float()),
+        double: gcWrap(Module.uno_Type.Double()),
+        char: gcWrap(Module.uno_Type.Char()),
+        string: gcWrap(Module.uno_Type.String()),
+        type: gcWrap(Module.uno_Type.Type()),
+        any: gcWrap(Module.uno_Type.Any()),
+        sequence(type) { return gcWrap(Module.uno_Type.Sequence(type)); },
+        enum(name) {
+          if (typeof name === 'function' && Object.hasOwn(name, Module.unoTagSymbol)
+            && name[Module.unoTagSymbol].kind === 'enum')
+          {
+            name = name[Module.unoTagSymbol].type;
+          }
+          return gcWrap(Module.uno_Type.Enum(name));
+        },
+        struct(name) {
+          if (typeof name === 'function' && Object.hasOwn(name, Module.unoTagSymbol)
+            && name[Module.unoTagSymbol].kind === 'struct')
+          {
+            name = name[Module.unoTagSymbol].type;
+          }
+          return gcWrap(Module.uno_Type.Struct(name));
+        },
+        exception(name) {
+          if (typeof name === 'function' && Object.hasOwn(name, Module.unoTagSymbol)
+            && name[Module.unoTagSymbol].kind === 'exception')
+          {
+            name = name[Module.unoTagSymbol].type;
+          }
+          return gcWrap(Module.uno_Type.Exception(name));
+        },
+        interface(name) {
+          if (typeof name === 'object' && Object.hasOwn(name, Module.unoTagSymbol)
+            && name[Module.unoTagSymbol].kind === 'interface')
+          {
+            name = name[Module.unoTagSymbol].type;
+          }
+          return gcWrap(Module.uno_Type.Interface(name));
+        }
+      },
+      Any,
+      getAnyType,
+      fromAny,
+      sameUnoObject: function(obj1, obj2) {
+        const type = Module.uno_Type.Interface('com.sun.star.uno.XInterface');
+        const toDelete = [];
+        try {
+          return Module.sameUnoObject(
+            translateToEmbind(obj1, type, toDelete),
+            translateToEmbind(obj2, type, toDelete));
+        } finally {
+          type.delete();
+          toDelete.forEach((val) => val.delete());
+        }
+      },
+      getUnoComponentContext: function() {
+        return proxy(Module.getUnoComponentContext());
+      },
+      throwUnoException,
+      catchUnoException,
+      uno,
+      unoObject: function(interfaces, obj) {
+        const wrapper = {};
+        const toDelete = [];
+        Module.uno$zetajs_deleteRegistry.register(wrapper, toDelete);
+        const seen = {
+          'com.sun.star.lang.XTypeProvider': true, 'com.sun.star.uno.XInterface': true};
+        function walk(td) {
+          const iname = td.getName();
+          if (!Object.hasOwn(seen, iname)) {
+            seen[iname] = true;
+            if (td.getTypeClass() !== Module.uno.com.sun.star.uno.TypeClass.INTERFACE) {
+              throw new Error('not a UNO interface type: ' + iname);
+            }
+            const itd = Module.uno.com.sun.star.reflection.XInterfaceTypeDescription2
+                  .query(td);
+            const bases = itd.getBaseTypes();
+            for (let i = 0; i !== bases.size(); ++i) {
+              const base = bases.get(i);
+              walk(base);
+              base.delete();
+            }
+            bases.delete();
+            const mems = itd.getMembers();
+            itd.delete();
+            for (let i = 0; i !== mems.size(); ++i) {
+              const ifc = mems.get(i);
+              const atd = Module.uno.com.sun.star.reflection
+                .XInterfaceAttributeTypeDescription.query(ifc);
+              ifc.delete();
+              if (atd !== null) {
+                const aname = atd.getMemberName();
+                const type = translateTypeDescriptionAndDelete(atd.getType());
+                toDelete.push(type);
+                wrapper['get' + aname] = function() {
+                  return translateToEmbind(
+                    obj['get' + aname].apply(obj), type, []);
+                };
+                if (!atd.isReadOnly()) {
+                  wrapper['set' + aname] = function() {
+                    obj['set' + aname].apply(
+                      obj, [translateFromEmbind(arguments[0], type, true, false)]);
+                  };
+                }
+                atd.delete();
+              } else {
+                const ifc = mems.get(i);
+                const mtd = Module.uno.com.sun.star.reflection
+                  .XInterfaceMethodTypeDescription.query(ifc);
+                ifc.delete();
+                const mname = mtd.getMemberName();
+                const retType = translateTypeDescriptionAndDelete(
+                  mtd.getReturnType());
+                toDelete.push(retType);
+                const params = [];
+                const descrs = mtd.getParameters();
+                mtd.delete();
+                for (let j = 0; j !== descrs.size(); ++j) {
+                  const descr = descrs.get(j);
+                  const type = translateTypeDescriptionAndDelete(descr.getType());
+                  toDelete.push(type);
+                  params.push({type, dirIn: descr.isIn(), dirOut: descr.isOut()});
+                  descr.delete();
+                }
+                descrs.delete();
+                wrapper[mname] = function() {
+                  const args = [];
+                  for (let i = 0; i !== params.length; ++i) {
+                    let arg;
+                    if (params[i].dirOut) {
+                      arg = {};
+                      if (params[i].dirIn) {
+                        arg.val = translateFromEmbind(
+                          arguments[i].val, params[i].type, true, false);
+                      }
+                    } else {
+                      arg = translateFromEmbind(
+                        arguments[i], params[i].type, true, false);
+                    }
+                    args.push(arg);
+                  }
+                  const ret = translateToEmbind(
+                    obj[mname].apply(obj, args), retType, []);
+                  for (let i = 0; i !== params.length; ++i) {
+                    if (params[i].dirOut) {
+                      arguments[i].val = translateToEmbind(
+                        args[i].val, params[i].type, []);
+                    }
+                  }
+                  return ret;
+                };
+              }
+            }
+            mems.delete();
+          }
+        };
+        const tdm = getTypeDescriptionManager();
+        const interfaceNames = [];
+        interfaces.forEach((i) => {
+          let name = i;
+          if (typeof name === 'object' && Object.hasOwn(name, Module.unoTagSymbol)
+              && name[Module.unoTagSymbol].kind === 'interface')
+          {
+              name = name[Module.unoTagSymbol].type;
+          } else if (name instanceof Module.uno_Type
+                     && (name.getTypeClass()
+                         === Module.uno.com.sun.star.uno.TypeClass.INTERFACE))
+          {
+            name = name.toString();
+          }
+          interfaceNames.push(name);
+          const tdAny = tdm.getByHierarchicalName(name);
+          const ifc = tdAny.get();
+          const td = Module.uno.com.sun.star.reflection.XTypeDescription.query(ifc);
+          ifc.delete();
+          walk(td);
+          td.delete();
+        })
+        tdm.delete();
+        return proxy(Module.unoObject(interfaceNames, wrapper));
+      },
+      mainPort: Module.uno_mainPort
+    };
+    resolve(zetajs);
+  };
+  Module.zetajs$reject = reject;
+});
+
+Module.uno_init.then(function() { Module.zetajs$resolve(); });
+
+/* vim:set shiftwidth=2 softtabstop=2 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */
\ No newline at end of file
diff --git a/src/lib/zetajs/zetaHelper.js b/src/lib/zetajs/zetaHelper.js
new file mode 100644
index 00000000..3743ae89
--- /dev/null
+++ b/src/lib/zetajs/zetaHelper.js
@@ -0,0 +1,209 @@
+// ATTENTION: Experimental code! Expect heavy API changes.
+/**
+ * Helper for code in the browsers main thread.
+ * @beta
+ */
+export class ZetaHelperMain {
+    /**
+     * Use absolute URLs or URLs relative to the root HTML document (location.href).
+     * @param threadJs - URL for JS code file running inside the office thread (web worker).
+     * @param options.threadJsType - 'classic' or 'module' (ES2015)
+     *   see: https://developer.mozilla.org/docs/Web/API/Worker/Worker#type
+     * @param options.wasmPkg - Which WASM binaries to use. Possible options:
+     *   'free', 'business', 'url:YOUR_CUSTOM_URL'
+     * @param options.blockPageScroll - Don't scroll the HTML page while the cursor is above
+     *   the canvas. (default: true)
+     */
+    constructor(threadJs, options) {
+        this.threadJsType = 'classic';
+        // Enable usage of LOWA builds with UI.
+        const canvas = document.getElementById('qtcanvas');
+        const thisFileUrl = import.meta.url;
+        const modUrlDir = thisFileUrl.substring(0, thisFileUrl.length - 'zetaHelper.js'.length);
+        if (threadJs)
+            threadJs = (new URL(threadJs, location.href)).toString();
+        const zetajsScript = modUrlDir + 'zeta.js';
+        const threadWrapScript = 'data:text/javascript;charset=UTF-8,' +
+            'import("' + import.meta.url + '").then(m => {m.zetaHelperWrapThread();});';
+        const wasmPkg = options.wasmPkg || 'free';
+        let soffice_base_url = ZetaHelperMain.wasmUrls[wasmPkg] || ZetaHelperMain.wasmUrls['free'];
+        if (wasmPkg?.substring(0, 4) === 'url:')
+            soffice_base_url = wasmPkg.substring(4, wasmPkg.length);
+        if (soffice_base_url === '')
+            soffice_base_url = './';
+        soffice_base_url = (new URL(soffice_base_url, location.href)).toString();
+        const Module = {
+            canvas,
+            uno_scripts: [zetajsScript, threadWrapScript],
+            locateFile: (path, prefix) => { return (prefix || soffice_base_url) + path; },
+            modUrlDir,
+        };
+        Module.mainScriptUrlOrBlob = new Blob(["importScripts('" + (new URL('soffice.js', soffice_base_url)) + "');"], { type: 'text/javascript' });
+        let lastDevicePixelRatio = window.devicePixelRatio;
+        addEventListener('resize', () => {
+            // Workaround to inform Qt5 about changed browser zoom.
+            setTimeout(() => {
+                if (lastDevicePixelRatio != -1) {
+                    if (lastDevicePixelRatio != window.devicePixelRatio) {
+                        lastDevicePixelRatio = -1;
+                        this.widthPxAdd(canvas.style, +1);
+                        window.dispatchEvent(new Event('resize'));
+                    }
+                }
+                else {
+                    lastDevicePixelRatio = window.devicePixelRatio;
+                    this.widthPxAdd(canvas.style, -1);
+                    window.dispatchEvent(new Event('resize'));
+                }
+            }, 100);
+        });
+        // Scroll only the canvas while the mouse cursor is above it.
+        if (options.blockPageScroll != false)
+            canvas.addEventListener('wheel', (event) => {
+                event.preventDefault();
+            }, { passive: false });
+        window.Module = Module; // window.* is global
+        this.canvas = canvas;
+        this.Module = Module;
+        this.threadJs = threadJs?.toString() || null;
+        if (options.threadJsType === 'module')
+            this.threadJsType = 'module';
+        this.soffice_base_url = soffice_base_url;
+    }
+    start(app_init) {
+        const zHM = this;
+        const soffice_js = document.createElement("script");
+        soffice_js.src = zHM.soffice_base_url + "soffice.js";
+        // "onload" runs after the loaded script has run.
+        soffice_js.onload = () => {
+            console.log('zetaHelper: Configuring Module');
+            zHM.Module.uno_main.then((pThrPort) => {
+                zHM.thrPort = pThrPort;
+                zHM.FS = window.FS;
+                zHM.thrPort.onmessage = (e) => {
+                    switch (e.data.cmd) {
+                        case 'ZetaHelper::thr_started':
+                            // Trigger resize of the embedded window to match the canvas size.
+                            // May somewhen be obsoleted by:
+                            //   https://gerrit.libreoffice.org/c/core/+/174040
+                            window.dispatchEvent(new Event('resize'));
+                            zHM.thrPort.postMessage({
+                                cmd: 'ZetaHelper::run_thr_script',
+                                threadJs: zHM.threadJs,
+                                threadJsType: zHM.threadJsType
+                            });
+                            app_init();
+                            break;
+                        default:
+                            throw Error('Unknown message command: ' + e.data.cmd);
+                    }
+                    ;
+                };
+            });
+        };
+        console.log('zetaHelper: Loading WASM binaries for ZetaJS from: ' + zHM.soffice_base_url);
+        // Hint: The global objects "canvas" and "Module" must exist before the next line.
+        document.body.appendChild(soffice_js);
+    }
+    widthPxAdd(obj, value) {
+        if (/\A\d+px\z/.test(obj.width)) {
+            obj.width = parseInt(obj.width) + value + 'px';
+        }
+    }
+}
+ZetaHelperMain.wasmUrls = {
+    free: 'https://cdn.zetaoffice.net/zetaoffice_latest/',
+    business: 'https://business-cdn.zetaoffice.net/zetaoffice_latest/',
+};
+/**
+ * Initializes zetajs in the office thread (web worker).
+ * Will be called by ZetaHelperMain.
+ * NOT MEANT FOR DIRECT USE
+ * @beta
+ */
+export function zetaHelperWrapThread() {
+    const zJsModule = globalThis.Module;
+    zJsModule.zetajs.then((zetajs) => {
+        const port = zetajs.mainPort;
+        port.onmessage = (e) => {
+            switch (e.data.cmd) {
+                case 'ZetaHelper::run_thr_script':
+                    port.onmessage = null;
+                    globalThis.zetajsStore = { zetajs, zJsModule };
+                    let threadJs = e.data.threadJs;
+                    if (threadJs) {
+                        if (e.data.threadJsType === 'module') {
+                            console.log('zetaHelper: Loading threadJs as module from: ' + threadJs);
+                            import(threadJs).then(module => {
+                                // Make exports of threadJs accessible for debugging.
+                                globalThis.zetajsStore.threadJsContext = module;
+                            });
+                        }
+                        else { // classic
+                            console.log('zetaHelper: Loading threadJs as script from: ' + threadJs);
+                            importScripts(threadJs);
+                        }
+                    }
+                    else {
+                        console.log('zetaHelper: Office loaded. No threadJs given.');
+                    }
+                    break;
+                default:
+                    throw Error('Unknown message command: ' + e.data.cmd);
+            }
+            ;
+        };
+        port.postMessage({
+            cmd: 'ZetaHelper::thr_started'
+        });
+    });
+}
+/**
+ * Helper for inside the office thread (web worker).
+ * @beta
+ */
+export class ZetaHelperThread {
+    constructor() {
+        this.zetajs = globalThis.zetajsStore.zetajs;
+        this.zJsModule = globalThis.zetajsStore.zJsModule;
+        this.thrPort = this.zetajs.mainPort;
+        this.css = this.zetajs.uno.com.sun.star;
+        this.context = this.zetajs.getUnoComponentContext();
+        this.desktop = this.css.frame.Desktop.create(this.context);
+        this.config = this.css.configuration.ReadWriteAccess.create(this.context, 'en-US');
+    }
+    /**
+     * Turn off toolbars.
+     * @param officeModules - ["Base", "Calc", "Draw", "Impress", "Math", "Writer"];
+     */
+    configDisableToolbars(officeModules) {
+        for (const mod of officeModules) {
+            const modName = "/org.openoffice.Office.UI." + mod + "WindowState/UIElements/States";
+            const uielems = this.config.getByHierarchicalName(modName);
+            for (const i of uielems.getElementNames()) {
+                if (i.startsWith("private:resource/toolbar/")) {
+                    const uielem = uielems.getByName(i); // SLOW OPERATION
+                    if (uielem.getByName('Visible')) {
+                        uielem.setPropertyValue('Visible', false);
+                    }
+                }
+            }
+        }
+        this.config.commitChanges();
+    }
+    /**
+     * @param unoUrl - string following ".uno:" (e.g. "Bold")
+     */
+    transformUrl(unoUrl) {
+        const ioparam = { val: new this.css.util.URL({ Complete: '.uno:' + unoUrl }) };
+        this.css.util.URLTransformer.create(this.context).parseStrict(ioparam);
+        return ioparam.val;
+    }
+    queryDispatch(ctrl, urlObj) {
+        return ctrl.queryDispatch(urlObj, '_self', 0);
+    }
+    dispatch(ctrl, unoUrl, params = []) {
+        const urlObj = this.transformUrl(unoUrl);
+        this.queryDispatch(ctrl, urlObj).dispatch(urlObj, params);
+    }
+}
diff --git a/src/tests/pdf-tools.test.ts b/src/tests/pdf-tools.test.ts
index 6370e755..8c01723c 100644
--- a/src/tests/pdf-tools.test.ts
+++ b/src/tests/pdf-tools.test.ts
@@ -19,7 +19,7 @@ describe('Tool Configuration Arrays', () => {
 
     it('should have the correct number of tools', () => {
       // This acts as a snapshot test to catch unexpected additions/removals.
-      expect(singlePdfLoadTools).toHaveLength(39);
+      expect(singlePdfLoadTools).toHaveLength(40);
     });
 
     it('should not contain any duplicate tools', () => {
diff --git a/src/types/globals.d.ts b/src/types/globals.d.ts
index 48c971c3..f8fc6c9f 100644
--- a/src/types/globals.d.ts
+++ b/src/types/globals.d.ts
@@ -1 +1,9 @@
 declare const __SIMPLE_MODE__: boolean;
+
+interface Window {
+  FS: {
+    writeFile: (path: string, data: Uint8Array) => void;
+    readFile: (path: string) => Uint8Array;
+    unlink: (path: string) => void;
+  };
+}
\ No newline at end of file
diff --git a/vite.config.ts b/vite.config.ts
index a13454ed..4cf02f59 100644
--- a/vite.config.ts
+++ b/vite.config.ts
@@ -39,6 +39,12 @@ export default defineConfig(({ mode }) => ({
       },
     },
   },
+  server: {
+    headers: {
+      'Cross-Origin-Opener-Policy': 'same-origin',
+      'Cross-Origin-Embedder-Policy': 'require-corp',
+    },
+  },
   test: {
     globals: true,
     environment: 'jsdom',
@@ -55,4 +61,4 @@ export default defineConfig(({ mode }) => ({
       ],
     },
   },
-}));
+}));
\ No newline at end of file