html-to-markdown-wasm 2.6.6 → 2.7.0

package/dist-web/html_to_markdown_wasm.js

@@ -227,6 +227,36 @@ function getArrayJsValueFromWasm0(ptr, len) {
     }
     return result;
 }
+/**
+ * @param {Uint8Array} html
+ * @param {any} options
+ * @returns {string}
+ */
+export function convertBytes(html, options) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.convertBytes(retptr, addHeapObject(html), addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr1 = r0;
+        var len1 = r1;
+        if (r3) {
+            ptr1 = 0; len1 = 0;
+            throw takeObject(r2);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Convert HTML to Markdown
  *
@@ -281,27 +311,59 @@ function _assertClass(instance, klass) {
     }
 }
 /**
- * Convert HTML to Markdown while collecting inline images
- *
- * # Arguments
- *
- * * `html` - The HTML string to convert
- * * `options` - Optional conversion options (as a JavaScript object)
- * * `image_config` - Configuration for inline image extraction
- *
- * # Example
- *
- * ```javascript
- * import { convertWithInlineImages, WasmInlineImageConfig } from '@html-to-markdown/wasm';
- *
- * const html = '<img src="data:image/png;base64,..." alt="test">';
- * const config = new WasmInlineImageConfig(1024 * 1024);
- * config.inferDimensions = true;
- *
- * const result = convertWithInlineImages(html, null, config);
- * console.log(result.markdown);
- * console.log(result.inlineImages.length);
- * ```
+ * @param {string} html
+ * @param {WasmConversionOptionsHandle} handle
+ * @returns {string}
+ */
+export function convertWithOptionsHandle(html, handle) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(html, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(handle, WasmConversionOptionsHandle);
+        wasm.convertWithOptionsHandle(retptr, ptr0, len0, handle.__wbg_ptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {any} options
+ * @returns {WasmConversionOptionsHandle}
+ */
+export function createConversionOptionsHandle(options) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.createConversionOptionsHandle(retptr, addHeapObject(options));
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return WasmConversionOptionsHandle.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
  * @param {string} html
  * @param {any} options
  * @param {WasmInlineImageConfig | null} [image_config]
@@ -330,6 +392,33 @@ export function convertWithInlineImages(html, options, image_config) {
     }
 }
 
+/**
+ * @param {Uint8Array} html
+ * @param {any} options
+ * @param {WasmInlineImageConfig | null} [image_config]
+ * @returns {WasmHtmlExtraction}
+ */
+export function convertBytesWithInlineImages(html, options, image_config) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        let ptr0 = 0;
+        if (!isLikeNone(image_config)) {
+            _assertClass(image_config, WasmInlineImageConfig);
+            ptr0 = image_config.__destroy_into_raw();
+        }
+        wasm.convertBytesWithInlineImages(retptr, addHeapObject(html), addHeapObject(options), ptr0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        if (r2) {
+            throw takeObject(r1);
+        }
+        return WasmHtmlExtraction.__wrap(r0);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
 /**
  * Initialize panic hook for better error messages in the browser
  */
@@ -337,6 +426,85 @@ export function init() {
     wasm.init();
 }
 
+/**
+ * @param {Uint8Array} html
+ * @param {WasmConversionOptionsHandle} handle
+ * @returns {string}
+ */
+export function convertBytesWithOptionsHandle(html, handle) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        _assertClass(handle, WasmConversionOptionsHandle);
+        wasm.convertBytesWithOptionsHandle(retptr, addHeapObject(html), handle.__wbg_ptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr1 = r0;
+        var len1 = r1;
+        if (r3) {
+            ptr1 = 0; len1 = 0;
+            throw takeObject(r2);
+        }
+        deferred2_0 = ptr1;
+        deferred2_1 = len1;
+        return getStringFromWasm0(ptr1, len1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
+    }
+}
+
+const WasmConversionOptionsHandleFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_wasmconversionoptionshandle_free(ptr >>> 0, 1));
+
+export class WasmConversionOptionsHandle {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(WasmConversionOptionsHandle.prototype);
+        obj.__wbg_ptr = ptr;
+        WasmConversionOptionsHandleFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmConversionOptionsHandleFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmconversionoptionshandle_free(ptr, 0);
+    }
+    /**
+     * @param {any} options
+     */
+    constructor(options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.wasmconversionoptionshandle_new(retptr, addHeapObject(options));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            WasmConversionOptionsHandleFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) WasmConversionOptionsHandle.prototype[Symbol.dispose] = WasmConversionOptionsHandle.prototype.free;
+
 const WasmHtmlExtractionFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_wasmhtmlextraction_free(ptr >>> 0, 1));
@@ -838,6 +1006,16 @@ function __wbg_get_imports() {
         const ret = result;
         return ret;
     };
+    imports.wbg.__wbg_instanceof_Object_10bb762262230c68 = function(arg0) {
+        let result;
+        try {
+            result = getObject(arg0) instanceof Object;
+        } catch (_) {
+            result = false;
+        }
+        const ret = result;
+        return ret;
+    };
     imports.wbg.__wbg_instanceof_Uint8Array_20c8e73002f7af98 = function(arg0) {
         let result;
         try {
@@ -860,6 +1038,10 @@ function __wbg_get_imports() {
         const ret = Symbol.iterator;
         return addHeapObject(ret);
     };
+    imports.wbg.__wbg_keys_b4d27b02ad14f4be = function(arg0) {
+        const ret = Object.keys(getObject(arg0));
+        return addHeapObject(ret);
+    };
     imports.wbg.__wbg_length_69bca3cb64fc8748 = function(arg0) {
         const ret = getObject(arg0).length;
         return ret;

package/dist-web/html_to_markdown_wasm_bg.wasm.d.ts

@@ -1,12 +1,19 @@
 /* tslint:disable */
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
+export const __wbg_wasmconversionoptionshandle_free: (a: number, b: number) => void;
 export const __wbg_wasmhtmlextraction_free: (a: number, b: number) => void;
 export const __wbg_wasminlineimage_free: (a: number, b: number) => void;
 export const __wbg_wasminlineimageconfig_free: (a: number, b: number) => void;
 export const __wbg_wasminlineimagewarning_free: (a: number, b: number) => void;
 export const convert: (a: number, b: number, c: number, d: number) => void;
+export const convertBytes: (a: number, b: number, c: number) => void;
+export const convertBytesWithInlineImages: (a: number, b: number, c: number, d: number) => void;
+export const convertBytesWithOptionsHandle: (a: number, b: number, c: number) => void;
 export const convertWithInlineImages: (a: number, b: number, c: number, d: number, e: number) => void;
+export const convertWithOptionsHandle: (a: number, b: number, c: number, d: number) => void;
+export const createConversionOptionsHandle: (a: number, b: number) => void;
+export const wasmconversionoptionshandle_new: (a: number, b: number) => void;
 export const wasmhtmlextraction_inlineImages: (a: number, b: number) => void;
 export const wasmhtmlextraction_markdown: (a: number, b: number) => void;
 export const wasmhtmlextraction_warnings: (a: number, b: number) => void;

package/dist-web/package.json

@@ -4,7 +4,7 @@
   "collaborators": [
     "Na'aman Hirschfeld <nhirschfeld@gmail.com>"
   ],
-  "version": "2.6.6",
+  "version": "2.7.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "html-to-markdown-wasm",
-  "version": "2.6.6",
+  "version": "2.7.0",
   "description": "High-performance HTML to Markdown converter - WebAssembly bindings",
   "main": "dist/html_to_markdown_wasm.js",
   "types": "dist/html_to_markdown_wasm.d.ts",
@@ -50,12 +50,10 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "test:wasm-pack": "wasm-pack test --headless --chrome",
-    "bench": "tsx benchmark.ts",
     "clean": "rm -rf dist dist-node dist-web node_modules pkg"
   },
   "devDependencies": {
     "@types/node": "^24.10.0",
-    "tinybench": "^5.1.0",
     "tsx": "^4.20.6",
     "vitest": "^4.0.8",
     "wasm-pack": "^0.13.1"