handlemyfile 0.1.0 → 0.2.0

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2026 HandleMyFile Contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2026 HandleMyFile Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -101,17 +101,24 @@ pip install handlemyfile
 ```python
 import handlemyfile
 
-# Option 1: File-to-file conversion
-handlemyfile.convert_file("input.pdf", "output.docx")
+# Option 1: File-to-file conversion (with optional progress callback)
+def on_progress(current, total, stage):
+    print(f"Page {current}/{total} [{stage}]")
 
-# Option 2: In-memory byte conversion
+handlemyfile.convert_file("input.pdf", "output.docx", on_progress=on_progress)
+
+# Option 2: In-memory byte conversion with typed errors
 with open("document.pdf", "rb") as f:
     pdf_bytes = f.read()
 
-docx_bytes = handlemyfile.convert(pdf_bytes)
-
-with open("converted.docx", "wb") as f:
-    f.write(docx_bytes)
+try:
+    docx_bytes = handlemyfile.convert(pdf_bytes)
+    with open("converted.docx", "wb") as f:
+        f.write(docx_bytes)
+except handlemyfile.PasswordProtectedError:
+    print("This PDF requires a password to open!")
+except handlemyfile.InvalidPdfError:
+    print("Invalid PDF file header.")
 ```
 
 ### Python CLI
@@ -134,48 +141,71 @@ The package compiles to WebAssembly with zero external dependencies, making it i
 npm install handlemyfile
 ```
 
-### Browser (ES Modules)
+### 1-Line Universal Usage (Browser, Vite, Next.js, Node.js)
 
-```javascript
-import init, { convert_pdf_to_docx } from 'handlemyfile';
+`handlemyfile` v0.2.0 introduces **zero-config auto-initialization**. You don't need to manually configure wasm asset URLs or call `init()`:
 
-async function convertFile(file) {
-    // Initialize WebAssembly runtime
-    await init();
+```typescript
+import { convert } from 'handlemyfile';
 
-    const arrayBuffer = await file.arrayBuffer();
-    const pdfBytes = new Uint8Array(arrayBuffer);
+// Auto-initializes WASM seamlessly in Browser or Node.js!
+const docxBytes = await convert(pdfBytes);
+```
 
-    // Convert PDF to Word DOCX
-    const docxBytes = convert_pdf_to_docx(pdfBytes);
+### Real-Time Progress Callback
 
-    // Create a download link for user
-    const blob = new Blob([docxBytes], {
-        type: 'application/vnd.openxmlformats-officedocument.wordprocessingml.document'
-    });
-    const url = URL.createObjectURL(blob);
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = 'converted.docx';
-    a.click();
-}
+For rich interactive progress bars (0% - 100%):
+
+```typescript
+import { convert } from 'handlemyfile';
+
+const docxBytes = await convert(pdfBytes, {
+  onProgress: ({ current, total, stage }) => {
+    console.log(`Page ${current}/${total} [${stage}]`);
+  }
+});
 ```
 
-### Node.js Usage
+### Non-Blocking Web Worker (Silky 60fps UI)
 
-```javascript
-import fs from 'fs';
-import init, { convert_pdf_to_docx } from 'handlemyfile';
+To convert large (100+ page) PDFs without freezing the browser's main thread:
 
-// Read wasm binary and initialize
-const wasmBuffer = fs.readFileSync('./node_modules/handlemyfile/handlemyfile_bg.wasm');
-await init(wasmBuffer);
+```typescript
+import { convert } from 'handlemyfile';
 
-const pdfData = fs.readFileSync('input.pdf');
-const docxData = convert_pdf_to_docx(new Uint8Array(pdfData));
+// Automatically offloads computation to a background Web Worker!
+const docxBytes = await convert(pdfBytes, {
+  worker: true,
+  onProgress: ({ current, total }) => {
+    updateProgressBar(current / total);
+  }
+});
+```
 
-fs.writeFileSync('output.docx', Buffer.from(docxData));
-console.log('Successfully generated output.docx');
+### Granular Error Handling
+
+```typescript
+import { convert, HandleMyFileError } from 'handlemyfile';
+
+try {
+  const docxBytes = await convert(pdfBytes);
+} catch (err) {
+  if (err instanceof HandleMyFileError) {
+    switch (err.code) {
+      case 'ERR_PASSWORD_PROTECTED':
+        alert('This PDF is password-protected.');
+        break;
+      case 'ERR_INVALID_HEADER':
+        alert('Invalid PDF format.');
+        break;
+      case 'ERR_CORRUPT_PDF':
+        alert('The PDF file is corrupted.');
+        break;
+      default:
+        console.error('Conversion failed:', err.message);
+    }
+  }
+}
 ```
 
 ---

package/handlemyfile.d.ts

@@ -6,6 +6,11 @@
  */
 export function convert_pdf_to_docx(pdf_data: Uint8Array | number[]): Uint8Array;
 
+/**
+ * WebAssembly entrypoint to convert PDF to DOCX with real-time page progress callback
+ */
+export function convert_pdf_to_docx_with_progress(pdf_data: Uint8Array | number[], progress_callback: Function): Uint8Array;
+
 /**
  * WebAssembly entrypoint to inspect parsed spatial elements & structured layout
  */
@@ -21,11 +26,14 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly convert_pdf_to_docx: (a: number, b: number) => [number, number, number, number];
+    readonly convert_pdf_to_docx_with_progress: (a: number, b: number, c: any) => [number, number, number, number];
     readonly inspect_pdf_elements: (a: number, b: number) => [number, number, number];
     readonly inspect_pdf_structure: (a: number, b: number) => [number, number, number];
     readonly __wbindgen_malloc: (a: number, b: number) => number;
     readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_exn_store: (a: number) => void;
+    readonly __externref_table_alloc: () => number;
     readonly __wbindgen_externrefs: WebAssembly.Table;
     readonly __externref_table_dealloc: (a: number) => void;
     readonly __wbindgen_start: () => void;

package/handlemyfile.js

@@ -17,6 +17,24 @@ export function convert_pdf_to_docx(pdf_data) {
     return v2;
 }
 
+/**
+ * WebAssembly entrypoint to convert PDF to DOCX with real-time page progress callback
+ * @param {Uint8Array | number[]} pdf_data
+ * @param {Function} progress_callback
+ * @returns {Uint8Array}
+ */
+export function convert_pdf_to_docx_with_progress(pdf_data, progress_callback) {
+    const ptr0 = passArray8ToWasm0(pdf_data, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.convert_pdf_to_docx_with_progress(ptr0, len0, progress_callback);
+    if (ret[3]) {
+        throw takeFromExternrefTable0(ret[2]);
+    }
+    var v2 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+    return v2;
+}
+
 /**
  * WebAssembly entrypoint to inspect parsed spatial elements & structured layout
  * @param {Uint8Array | number[]} pdf_data
@@ -67,6 +85,10 @@ function __wbg_get_imports() {
         __wbg___wbindgen_throw_4c88d8bf264fd984: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
+        __wbg_call_275b78b3b6520b92: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = arg0.call(arg1, arg2, arg3, arg4);
+            return ret;
+        }, arguments); },
         __wbg_new_37eb45aaf5eeb820: function() {
             const ret = new Array();
             return ret;
@@ -119,6 +141,12 @@ function __wbg_get_imports() {
     };
 }
 
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
 function getArrayU8FromWasm0(ptr, len) {
     ptr = ptr >>> 0;
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
@@ -145,6 +173,15 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);

package/handlemyfile_bg.wasm.d.ts

@@ -0,0 +1,15 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const convert_pdf_to_docx: (a: number, b: number) => [number, number, number, number];
+export const convert_pdf_to_docx_with_progress: (a: number, b: number, c: any) => [number, number, number, number];
+export const inspect_pdf_elements: (a: number, b: number) => [number, number, number];
+export const inspect_pdf_structure: (a: number, b: number) => [number, number, number];
+export const __wbindgen_malloc: (a: number, b: number) => number;
+export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_free: (a: number, b: number, c: number) => void;
+export const __wbindgen_exn_store: (a: number) => void;
+export const __externref_table_alloc: () => number;
+export const __wbindgen_externrefs: WebAssembly.Table;
+export const __externref_table_dealloc: (a: number) => void;
+export const __wbindgen_start: () => void;

package/index.d.ts

@@ -0,0 +1,86 @@
+export interface ProgressEvent {
+    current: number;
+    total: number;
+    stage: 'parsing' | 'analyzing_layout' | 'generating_docx' | 'done' | string;
+}
+
+export interface ConvertOptions {
+    /**
+     * Real-time progress callback with current page, total pages, and stage.
+     */
+    onProgress?: (progress: ProgressEvent) => void;
+
+    /**
+     * Optional custom URL or BufferSource for handlemyfile_bg.wasm.
+     * If omitted, it will automatically resolve via import.meta.url or Node.js fs.
+     */
+    wasmUrl?: string | URL | BufferSource;
+
+    /**
+     * When true in a browser environment, automatically spawns a background Web Worker
+     * to keep the main thread and UI completely non-blocking (60fps).
+     * @default false
+     */
+    worker?: boolean;
+}
+
+export type ErrorCode =
+    | 'ERR_PASSWORD_PROTECTED'
+    | 'ERR_INVALID_HEADER'
+    | 'ERR_CORRUPT_PDF'
+    | 'ERR_EMPTY_DOCUMENT'
+    | 'ERR_CONVERSION_FAILED'
+    | 'ERR_WORKER';
+
+export class HandleMyFileError extends Error {
+    code: ErrorCode;
+    constructor(message: string, code?: ErrorCode);
+}
+
+/**
+ * Universal auto-initializer for WASM runtime.
+ * Optional: Calling convert() automatically initializes if not already done.
+ */
+export function ensureInitialized(wasmUrlOrPath?: string | URL | BufferSource): Promise<void>;
+
+/**
+ * High-Level, Zero-Config PDF to DOCX converter.
+ * Automatically initializes WebAssembly if not already loaded.
+ *
+ * @example
+ * ```typescript
+ * import { convert } from 'handlemyfile';
+ *
+ * // 1-line conversion!
+ * const docxBytes = await convert(pdfBytes);
+ *
+ * // With real-time progress:
+ * const docxBytes = await convert(pdfBytes, {
+ *   onProgress: ({ current, total, stage }) => {
+ *     console.log(`Page ${current}/${total} [${stage}]`);
+ *   }
+ * });
+ *
+ * // Off-main-thread in Web Worker:
+ * const docxBytes = await convert(pdfBytes, { worker: true });
+ * ```
+ */
+export function convert(pdfData: Uint8Array | ArrayBuffer, options?: ConvertOptions): Promise<Uint8Array>;
+
+/**
+ * Synchronous converter for performance-critical environments where wasm is already initialized.
+ */
+export function convertSync(pdfData: Uint8Array | ArrayBuffer): Uint8Array;
+
+/**
+ * Run PDF conversion inside an isolated Web Worker to keep the browser UI completely responsive.
+ */
+export function convertInWorker(pdfBytes: Uint8Array | ArrayBuffer, options?: ConvertOptions): Promise<Uint8Array>;
+
+export function init(moduleOrPath?: any): Promise<any>;
+export function convert_pdf_to_docx(pdf_data: Uint8Array | number[]): Uint8Array;
+export function convert_pdf_to_docx_with_progress(pdf_data: Uint8Array | number[], progress_callback: Function): Uint8Array;
+export function inspect_pdf_elements(pdf_data: Uint8Array | number[]): any;
+export function inspect_pdf_structure(pdf_data: Uint8Array | number[]): any;
+
+export default convert;

package/index.js

@@ -0,0 +1,207 @@
+import initWasm, {
+    convert_pdf_to_docx,
+    convert_pdf_to_docx_with_progress,
+    inspect_pdf_elements,
+    inspect_pdf_structure
+} from './handlemyfile.js';
+
+export {
+    initWasm as init,
+    convert_pdf_to_docx,
+    convert_pdf_to_docx_with_progress,
+    inspect_pdf_elements,
+    inspect_pdf_structure
+};
+
+export class HandleMyFileError extends Error {
+    constructor(message, code = 'ERR_CONVERSION_FAILED') {
+        super(message);
+        this.name = 'HandleMyFileError';
+        this.code = code;
+    }
+}
+
+let isInitialized = false;
+let initPromise = null;
+
+function parseErrorCode(rawMessage) {
+    const msg = String(rawMessage || '');
+    if (msg.includes('ERR_PASSWORD_PROTECTED')) {
+        return { code: 'ERR_PASSWORD_PROTECTED', message: 'The PDF document is encrypted or password-protected.' };
+    }
+    if (msg.includes('ERR_INVALID_HEADER')) {
+        return { code: 'ERR_INVALID_HEADER', message: 'The provided file is not a valid PDF document (missing %PDF- header).' };
+    }
+    if (msg.includes('ERR_EMPTY_DOCUMENT')) {
+        return { code: 'ERR_EMPTY_DOCUMENT', message: 'The PDF document contains zero readable pages.' };
+    }
+    if (msg.includes('ERR_CORRUPT_PDF')) {
+        return { code: 'ERR_CORRUPT_PDF', message: 'Failed to parse PDF binary or cross-reference streams (file may be corrupted).' };
+    }
+    return { code: 'ERR_CONVERSION_FAILED', message: msg || 'Document conversion failed.' };
+}
+
+/**
+ * Universal auto-initializer that seamlessly detects Node.js vs Browser environments.
+ */
+export async function ensureInitialized(wasmUrlOrPath) {
+    if (isInitialized) return;
+    if (initPromise) return initPromise;
+
+    initPromise = (async () => {
+        // 1. If explicit path or bytes provided
+        if (wasmUrlOrPath) {
+            await initWasm({ module_or_path: wasmUrlOrPath });
+            isInitialized = true;
+            return;
+        }
+
+        // 2. Node.js environment detection
+        const isNode = typeof process !== 'undefined' && process.versions && !!process.versions.node;
+        if (isNode) {
+            try {
+                const fs = await import('fs');
+                const path = await import('path');
+                const url = await import('url');
+                const dir = path.dirname(url.fileURLToPath(import.meta.url));
+                const wasmPath = path.join(dir, 'handlemyfile_bg.wasm');
+                const wasmBuffer = fs.readFileSync(wasmPath);
+                await initWasm({ module_or_path: wasmBuffer });
+                isInitialized = true;
+                return;
+            } catch (err) {
+                // Fallback to default if dynamic import fails
+            }
+        }
+
+        // 3. Browser / Bundler environment (Vite, Webpack, Rollup)
+        const defaultWasmUrl = new URL('./handlemyfile_bg.wasm', import.meta.url);
+        await initWasm({ module_or_path: defaultWasmUrl });
+        isInitialized = true;
+    })();
+
+    return initPromise;
+}
+
+/**
+ * High-Level, Zero-Config PDF to DOCX converter.
+ * Auto-initializes WASM if not already loaded.
+ *
+ * @param {Uint8Array | ArrayBuffer} pdfData - Input PDF bytes.
+ * @param {Object} [options] - Conversion options.
+ * @param {Function} [options.onProgress] - Progress callback: ({ current, total, stage }).
+ * @param {string | URL | BufferSource} [options.wasmUrl] - Custom URL or BufferSource for .wasm file.
+ * @param {boolean} [options.worker] - Run conversion off the main thread in a Web Worker.
+ * @returns {Promise<Uint8Array>} Generated DOCX bytes.
+ */
+export async function convert(pdfData, options = {}) {
+    const inputBytes = pdfData instanceof Uint8Array ? pdfData : new Uint8Array(pdfData);
+
+    if (options.worker) {
+        return convertInWorker(inputBytes, options);
+    }
+
+    await ensureInitialized(options.wasmUrl);
+
+    try {
+        if (typeof options.onProgress === 'function') {
+            return convert_pdf_to_docx_with_progress(inputBytes, (current, total, stage) => {
+                options.onProgress({ current, total, stage });
+            });
+        }
+        return convert_pdf_to_docx(inputBytes);
+    } catch (err) {
+        const { code, message } = parseErrorCode(err);
+        throw new HandleMyFileError(message, code);
+    }
+}
+
+/**
+ * Synchronous converter for performance-critical environments where wasm is already initialized.
+ *
+ * @param {Uint8Array | ArrayBuffer} pdfData
+ * @returns {Uint8Array}
+ */
+export function convertSync(pdfData) {
+    const inputBytes = pdfData instanceof Uint8Array ? pdfData : new Uint8Array(pdfData);
+    try {
+        return convert_pdf_to_docx(inputBytes);
+    } catch (err) {
+        const { code, message } = parseErrorCode(err);
+        throw new HandleMyFileError(message, code);
+    }
+}
+
+/**
+ * Run PDF conversion inside an isolated Web Worker to keep the browser UI 60fps responsive.
+ *
+ * @param {Uint8Array} pdfBytes
+ * @param {Object} [options]
+ * @returns {Promise<Uint8Array>}
+ */
+export async function convertInWorker(pdfBytes, options = {}) {
+    if (typeof Worker === 'undefined') {
+        // Fallback to main thread if Web Workers are not supported (e.g. Node.js without worker_threads)
+        return convert(pdfBytes, { ...options, worker: false });
+    }
+
+    const wasmUrl = options.wasmUrl
+        ? String(options.wasmUrl)
+        : new URL('./handlemyfile_bg.wasm', import.meta.url).href;
+
+    // Inline worker script that imports this module
+    const workerCode = `
+        import { convert } from ${JSON.stringify(import.meta.url)};
+
+        self.onmessage = async (e) => {
+            const { id, pdfBytes, wasmUrl } = e.data;
+            try {
+                const docx = await convert(pdfBytes, {
+                    wasmUrl,
+                    onProgress: (p) => self.postMessage({ id, type: 'progress', progress: p })
+                });
+                self.postMessage({ id, type: 'success', docx }, [docx.buffer]);
+            } catch (err) {
+                self.postMessage({ id, type: 'error', error: err.message, code: err.code || 'ERR_CONVERSION_FAILED' });
+            }
+        };
+    `;
+
+    const blob = new Blob([workerCode], { type: 'application/javascript' });
+    const blobUrl = URL.createObjectURL(blob);
+    const worker = new Worker(blobUrl, { type: 'module' });
+
+    return new Promise((resolve, reject) => {
+        const id = Math.random().toString(36).substring(2);
+
+        worker.onmessage = (e) => {
+            if (e.data.id !== id) return;
+            if (e.data.type === 'progress') {
+                if (typeof options.onProgress === 'function') {
+                    options.onProgress(e.data.progress);
+                }
+            } else if (e.data.type === 'success') {
+                cleanup();
+                resolve(e.data.docx);
+            } else if (e.data.type === 'error') {
+                cleanup();
+                reject(new HandleMyFileError(e.data.error, e.data.code));
+            }
+        };
+
+        worker.onerror = (err) => {
+            cleanup();
+            reject(new HandleMyFileError(err.message || 'Worker failure', 'ERR_WORKER'));
+        };
+
+        function cleanup() {
+            worker.terminate();
+            URL.revokeObjectURL(blobUrl);
+        }
+
+        // Send binary copy to worker
+        worker.postMessage({ id, pdfBytes, wasmUrl });
+    });
+}
+
+export default convert;

package/package.json

@@ -1,31 +1,50 @@
 {
   "name": "handlemyfile",
   "type": "module",
-  "collaborators": [
-    "HandleMyFile Contributors"
-  ],
+  "version": "0.2.0",
   "description": "High-precision PDF to DOCX converter engine in Pure Rust, WebAssembly, and Python",
-  "version": "0.1.0",
   "license": "MIT",
+  "author": "HandleMyFile Contributors",
   "repository": {
     "type": "git",
     "url": "https://github.com/handlemyfile/handlemyfile"
   },
   "files": [
     "handlemyfile_bg.wasm",
+    "handlemyfile_bg.wasm.d.ts",
     "handlemyfile.js",
-    "handlemyfile.d.ts"
+    "handlemyfile.d.ts",
+    "index.js",
+    "index.d.ts",
+    "README.md",
+    "LICENSE"
   ],
-  "main": "handlemyfile.js",
-  "types": "handlemyfile.d.ts",
+  "main": "index.js",
+  "module": "index.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "default": "./index.js"
+    },
+    "./wasm": {
+      "types": "./handlemyfile.d.ts",
+      "import": "./handlemyfile.js",
+      "default": "./handlemyfile.js"
+    },
+    "./package.json": "./package.json"
+  },
   "sideEffects": [
-    "./snippets/*"
+    "./handlemyfile_bg.wasm"
   ],
   "keywords": [
     "pdf",
     "docx",
     "converter",
     "word",
-    "layout-analysis"
+    "wasm",
+    "webassembly",
+    "rust"
   ]
-}
+}