@quillmark/wasm 0.66.1 → 0.67.0

package/README.md

@@ -85,6 +85,48 @@ Render with a pre-parsed `Document`.
 ### `quill.open(parsed)` + `session.render(opts?)`
 Open once, render all or selected pages (`opts.pages`).
 
+The session also exposes `pageCount`, `backendId`, `warnings` (snapshot of
+session-level diagnostics attached at `open` time), `pageSize(page)`, and
+`paint(ctx, page, scale)` for canvas previews. See below.
+
+### Canvas Preview (Typst only)
+
+`session.paint(ctx, page, scale)` rasterizes a page directly into a
+`CanvasRenderingContext2D`, skipping PNG/SVG byte round-trips. Pair with
+`session.pageSize(page)` to size the canvas:
+
+```ts
+const dpr = window.devicePixelRatio || 1;
+const userZoom = 1;                              // your zoom UI
+const scale = dpr * userZoom;                    // multiplier on 72 ppi
+
+const { widthPt, heightPt } = session.pageSize(0);
+// Reassigning canvas.width/height clears the backing store, which is what
+// you want between pages. If you reuse the same canvas at the same size
+// (e.g. repaint after a zoom that didn't change scale), call
+// ctx.clearRect(0, 0, canvas.width, canvas.height) before paint instead.
+canvas.width  = Math.round(widthPt  * scale);    // device px
+canvas.height = Math.round(heightPt * scale);
+canvas.style.width  = `${widthPt  * userZoom}px`;
+canvas.style.height = `${heightPt * userZoom}px`;
+
+session.paint(canvas.getContext("2d"), 0, scale);
+```
+
+- `scale` is a multiplier on Typst's natural 72 ppi (1 pt → 1 device
+  pixel at `scale = 1`). Always include `devicePixelRatio` for crisp
+  output.
+- `pageCount` and `pageSize(page)` are stable for the session's
+  lifetime (immutable snapshot) — cache them.
+- Setting `canvas.width` / `canvas.height` clears the backing store; if
+  you reuse a canvas without resizing, call `clearRect` before `paint`.
+- Currently main-thread only: `paint` accepts `CanvasRenderingContext2D`,
+  not `OffscreenCanvasRenderingContext2D`. Worker support is on the
+  follow-up list.
+- Backend support: Typst only. Calling `paint` on a session opened by
+  any other backend throws an error that includes the resolved
+  `backendId`.
+
 ### Errors
 
 Every method that can fail throws a JS `Error` with `.diagnostics` attached:

package/bundler/wasm.d.ts

@@ -13,6 +13,19 @@ export interface CardInput {
 }
 
 
+
+/**
+ * Page dimensions in Typst points (1 pt = 1/72 inch).
+ *
+ * Returned by `RenderSession.pageSize`. Use these to size a canvas backing
+ * store (`widthPt * scale × heightPt * scale`) before calling `paint`.
+ */
+export interface PageSize {
+    widthPt: number;
+    heightPt: number;
+}
+
+
 export interface Artifact {
     format: OutputFormat;
     bytes: Uint8Array;
@@ -382,14 +395,67 @@ export class RenderSession {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Page dimensions in Typst points (1 pt = 1/72 inch).
+     *
+     * Stable for a given `page` across the session's lifetime — the
+     * compiled document is an immutable snapshot, so callers can cache
+     * results.
+     *
+     * Throws if the underlying backend has no canvas painter (i.e. is not
+     * the Typst backend) or if `page` is out of range.
+     */
+    pageSize(page: number): PageSize;
+    /**
+     * Paint `page` into a 2D canvas context.
+     *
+     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
+     * `scale = 1`). Typical usage:
+     * `scale = (window.devicePixelRatio || 1) * userZoom`.
+     *
+     * The caller must size `ctx.canvas` so that
+     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
+     * round(heightPt * scale)` *before* calling `paint`. Setting
+     * `canvas.width` / `canvas.height` clears the backing store, which is
+     * the recommended way to handle page-to-page transitions; if you
+     * reuse a canvas without resizing, call
+     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
+     * stale pixels showing through transparent regions.
+     *
+     * `paint` writes into the backing store at origin `(0, 0)` and does
+     * not clear outside the rendered region.
+     *
+     * Throws if the backend does not support canvas preview (the message
+     * includes the resolved `backendId` for debugging), or if `page` is
+     * out of range.
+     */
+    paint(ctx: CanvasRenderingContext2D, page: number, scale: number): void;
     /**
      * Render all or selected pages from this session.
      */
     render(opts?: RenderOptions | null): RenderResult;
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     */
+    readonly backendId: string;
     /**
      * Number of pages in this render session.
+     *
+     * Stable for the lifetime of the session — the underlying compiled
+     * document is an immutable snapshot.
      */
     readonly pageCount: number;
+    /**
+     * Session-level warnings attached at `quill.open(...)` time.
+     *
+     * Snapshot of any non-fatal diagnostics emitted while opening the
+     * session (e.g. version compatibility shims). Stable across the
+     * session's lifetime. These are also appended to
+     * [`RenderResult.warnings`] on every `render()` call; the accessor
+     * surfaces them to canvas-preview consumers that don't go through
+     * `render()`.
+     */
+    readonly warnings: Diagnostic[];
 }
 
 /**

package/bundler/wasm_bg.js

@@ -757,14 +757,104 @@ export class RenderSession {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_rendersession_free(ptr, 0);
     }
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     * @returns {string}
+     */
+    get backendId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_backendId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Number of pages in this render session.
+     *
+     * Stable for the lifetime of the session — the underlying compiled
+     * document is an immutable snapshot.
      * @returns {number}
      */
     get pageCount() {
         const ret = wasm.rendersession_pageCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Page dimensions in Typst points (1 pt = 1/72 inch).
+     *
+     * Stable for a given `page` across the session's lifetime — the
+     * compiled document is an immutable snapshot, so callers can cache
+     * results.
+     *
+     * Throws if the underlying backend has no canvas painter (i.e. is not
+     * the Typst backend) or if `page` is out of range.
+     * @param {number} page
+     * @returns {PageSize}
+     */
+    pageSize(page) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_pageSize(retptr, this.__wbg_ptr, page);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Paint `page` into a 2D canvas context.
+     *
+     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
+     * `scale = 1`). Typical usage:
+     * `scale = (window.devicePixelRatio || 1) * userZoom`.
+     *
+     * The caller must size `ctx.canvas` so that
+     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
+     * round(heightPt * scale)` *before* calling `paint`. Setting
+     * `canvas.width` / `canvas.height` clears the backing store, which is
+     * the recommended way to handle page-to-page transitions; if you
+     * reuse a canvas without resizing, call
+     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
+     * stale pixels showing through transparent regions.
+     *
+     * `paint` writes into the backing store at origin `(0, 0)` and does
+     * not clear outside the rendered region.
+     *
+     * Throws if the backend does not support canvas preview (the message
+     * includes the resolved `backendId` for debugging), or if `page` is
+     * out of range.
+     * @param {CanvasRenderingContext2D} ctx
+     * @param {number} page
+     * @param {number} scale
+     */
+    paint(ctx, page, scale) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_paint(retptr, this.__wbg_ptr, addBorrowedObject(ctx), page, scale);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
     /**
      * Render all or selected pages from this session.
      * @param {RenderOptions | null} [opts]
@@ -785,6 +875,21 @@ export class RenderSession {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Session-level warnings attached at `quill.open(...)` time.
+     *
+     * Snapshot of any non-fatal diagnostics emitted while opening the
+     * session (e.g. version compatibility shims). Stable across the
+     * session's lifetime. These are also appended to
+     * [`RenderResult.warnings`] on every `render()` call; the accessor
+     * surfaces them to canvas-preview consumers that don't go through
+     * `render()`.
+     * @returns {Diagnostic[]}
+     */
+    get warnings() {
+        const ret = wasm.rendersession_warnings(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 if (Symbol.dispose) RenderSession.prototype[Symbol.dispose] = RenderSession.prototype.free;
 
@@ -1040,6 +1145,10 @@ export function __wbg_new_aa8d0fa9762c29bd() {
     const ret = new Object();
     return addHeapObject(ret);
 }
+export function __wbg_new_with_u8_clamped_array_and_sh_fe957411824b5158() { return handleError(function (arg0, arg1, arg2, arg3) {
+    const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
+    return addHeapObject(ret);
+}, arguments); }
 export function __wbg_next_0340c4ae324393c3() { return handleError(function (arg0) {
     const ret = getObject(arg0).next();
     return addHeapObject(ret);
@@ -1055,6 +1164,9 @@ export function __wbg_now_a9b7df1cbee90986() {
 export function __wbg_prototypesetcall_a6b02eb00b0f4ce2(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 }
+export function __wbg_putImageData_c810e62ea70e761d() { return handleError(function (arg0, arg1, arg2, arg3) {
+    getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
+}, arguments); }
 export function __wbg_set_022bee52d0b05b19() { return handleError(function (arg0, arg1, arg2) {
     const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
     return ret;
@@ -1143,6 +1255,12 @@ function _assertClass(instance, klass) {
     }
 }
 
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -1219,6 +1337,11 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function getClampedArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -1240,6 +1363,14 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+let cachedUint8ClampedArrayMemory0 = null;
+function getUint8ClampedArrayMemory0() {
+    if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) {
+        cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+    }
+    return cachedUint8ClampedArrayMemory0;
+}
+
 function getObject(idx) { return heap[idx]; }
 
 function handleError(f, args) {
@@ -1296,6 +1427,8 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
+let stack_pointer = 1024;
+
 function takeObject(idx) {
     const ret = getObject(idx);
     dropObject(idx);

package/bundler/wasm_bg.wasm.d.ts

@@ -37,8 +37,12 @@ export const quill_open: (a: number, b: number, c: number) => void;
 export const quill_render: (a: number, b: number, c: number, d: number) => void;
 export const quillmark_new: () => number;
 export const quillmark_quill: (a: number, b: number, c: number) => void;
+export const rendersession_backendId: (a: number, b: number) => void;
 export const rendersession_pageCount: (a: number) => number;
+export const rendersession_pageSize: (a: number, b: number, c: number) => void;
+export const rendersession_paint: (a: number, b: number, c: number, d: number, e: number) => void;
 export const rendersession_render: (a: number, b: number, c: number) => void;
+export const rendersession_warnings: (a: number) => number;
 export const lut_inverse_interp16: (a: number, b: number, c: number) => number;
 export const qcms_profile_precache_output_transform: (a: number) => void;
 export const qcms_white_point_sRGB: (a: number) => void;

package/node-esm/wasm.d.ts

@@ -13,6 +13,19 @@ export interface CardInput {
 }
 
 
+
+/**
+ * Page dimensions in Typst points (1 pt = 1/72 inch).
+ *
+ * Returned by `RenderSession.pageSize`. Use these to size a canvas backing
+ * store (`widthPt * scale × heightPt * scale`) before calling `paint`.
+ */
+export interface PageSize {
+    widthPt: number;
+    heightPt: number;
+}
+
+
 export interface Artifact {
     format: OutputFormat;
     bytes: Uint8Array;
@@ -382,14 +395,67 @@ export class RenderSession {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Page dimensions in Typst points (1 pt = 1/72 inch).
+     *
+     * Stable for a given `page` across the session's lifetime — the
+     * compiled document is an immutable snapshot, so callers can cache
+     * results.
+     *
+     * Throws if the underlying backend has no canvas painter (i.e. is not
+     * the Typst backend) or if `page` is out of range.
+     */
+    pageSize(page: number): PageSize;
+    /**
+     * Paint `page` into a 2D canvas context.
+     *
+     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
+     * `scale = 1`). Typical usage:
+     * `scale = (window.devicePixelRatio || 1) * userZoom`.
+     *
+     * The caller must size `ctx.canvas` so that
+     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
+     * round(heightPt * scale)` *before* calling `paint`. Setting
+     * `canvas.width` / `canvas.height` clears the backing store, which is
+     * the recommended way to handle page-to-page transitions; if you
+     * reuse a canvas without resizing, call
+     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
+     * stale pixels showing through transparent regions.
+     *
+     * `paint` writes into the backing store at origin `(0, 0)` and does
+     * not clear outside the rendered region.
+     *
+     * Throws if the backend does not support canvas preview (the message
+     * includes the resolved `backendId` for debugging), or if `page` is
+     * out of range.
+     */
+    paint(ctx: CanvasRenderingContext2D, page: number, scale: number): void;
     /**
      * Render all or selected pages from this session.
      */
     render(opts?: RenderOptions | null): RenderResult;
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     */
+    readonly backendId: string;
     /**
      * Number of pages in this render session.
+     *
+     * Stable for the lifetime of the session — the underlying compiled
+     * document is an immutable snapshot.
      */
     readonly pageCount: number;
+    /**
+     * Session-level warnings attached at `quill.open(...)` time.
+     *
+     * Snapshot of any non-fatal diagnostics emitted while opening the
+     * session (e.g. version compatibility shims). Stable across the
+     * session's lifetime. These are also appended to
+     * [`RenderResult.warnings`] on every `render()` call; the accessor
+     * surfaces them to canvas-preview consumers that don't go through
+     * `render()`.
+     */
+    readonly warnings: Diagnostic[];
 }
 
 /**

package/node-esm/wasm.js

@@ -761,14 +761,104 @@ export class RenderSession {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_rendersession_free(ptr, 0);
     }
+    /**
+     * The backend that produced this session (e.g. `"typst"`).
+     * @returns {string}
+     */
+    get backendId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_backendId(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Number of pages in this render session.
+     *
+     * Stable for the lifetime of the session — the underlying compiled
+     * document is an immutable snapshot.
      * @returns {number}
      */
     get pageCount() {
         const ret = wasm.rendersession_pageCount(this.__wbg_ptr);
         return ret >>> 0;
     }
+    /**
+     * Page dimensions in Typst points (1 pt = 1/72 inch).
+     *
+     * Stable for a given `page` across the session's lifetime — the
+     * compiled document is an immutable snapshot, so callers can cache
+     * results.
+     *
+     * Throws if the underlying backend has no canvas painter (i.e. is not
+     * the Typst backend) or if `page` is out of range.
+     * @param {number} page
+     * @returns {PageSize}
+     */
+    pageSize(page) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_pageSize(retptr, this.__wbg_ptr, page);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Paint `page` into a 2D canvas context.
+     *
+     * `scale` multiplies Typst's natural 72 ppi (1 pt → 1 device pixel at
+     * `scale = 1`). Typical usage:
+     * `scale = (window.devicePixelRatio || 1) * userZoom`.
+     *
+     * The caller must size `ctx.canvas` so that
+     * `canvas.width === round(widthPt * scale)` and `canvas.height ===
+     * round(heightPt * scale)` *before* calling `paint`. Setting
+     * `canvas.width` / `canvas.height` clears the backing store, which is
+     * the recommended way to handle page-to-page transitions; if you
+     * reuse a canvas without resizing, call
+     * `ctx.clearRect(0, 0, canvas.width, canvas.height)` first to avoid
+     * stale pixels showing through transparent regions.
+     *
+     * `paint` writes into the backing store at origin `(0, 0)` and does
+     * not clear outside the rendered region.
+     *
+     * Throws if the backend does not support canvas preview (the message
+     * includes the resolved `backendId` for debugging), or if `page` is
+     * out of range.
+     * @param {CanvasRenderingContext2D} ctx
+     * @param {number} page
+     * @param {number} scale
+     */
+    paint(ctx, page, scale) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.rendersession_paint(retptr, this.__wbg_ptr, addBorrowedObject(ctx), page, scale);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            heap[stack_pointer++] = undefined;
+        }
+    }
     /**
      * Render all or selected pages from this session.
      * @param {RenderOptions | null} [opts]
@@ -789,6 +879,21 @@ export class RenderSession {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Session-level warnings attached at `quill.open(...)` time.
+     *
+     * Snapshot of any non-fatal diagnostics emitted while opening the
+     * session (e.g. version compatibility shims). Stable across the
+     * session's lifetime. These are also appended to
+     * [`RenderResult.warnings`] on every `render()` call; the accessor
+     * surfaces them to canvas-preview consumers that don't go through
+     * `render()`.
+     * @returns {Diagnostic[]}
+     */
+    get warnings() {
+        const ret = wasm.rendersession_warnings(this.__wbg_ptr);
+        return takeObject(ret);
+    }
 }
 if (Symbol.dispose) RenderSession.prototype[Symbol.dispose] = RenderSession.prototype.free;
 
@@ -1047,6 +1152,10 @@ function __wbg_get_imports() {
             const ret = new Object();
             return addHeapObject(ret);
         },
+        __wbg_new_with_u8_clamped_array_and_sh_fe957411824b5158: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
         __wbg_next_0340c4ae324393c3: function() { return handleError(function (arg0) {
             const ret = getObject(arg0).next();
             return addHeapObject(ret);
@@ -1062,6 +1171,9 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_a6b02eb00b0f4ce2: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_putImageData_c810e62ea70e761d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
+        }, arguments); },
         __wbg_set_022bee52d0b05b19: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
             return ret;
@@ -1157,6 +1269,12 @@ function _assertClass(instance, klass) {
     }
 }
 
+function addBorrowedObject(obj) {
+    if (stack_pointer == 1) throw new Error('out of js stack');
+    heap[--stack_pointer] = obj;
+    return stack_pointer;
+}
+
 function debugString(val) {
     // primitive types
     const type = typeof val;
@@ -1233,6 +1351,11 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function getClampedArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ClampedArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
 let cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
     if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
@@ -1254,6 +1377,14 @@ function getUint8ArrayMemory0() {
     return cachedUint8ArrayMemory0;
 }
 
+let cachedUint8ClampedArrayMemory0 = null;
+function getUint8ClampedArrayMemory0() {
+    if (cachedUint8ClampedArrayMemory0 === null || cachedUint8ClampedArrayMemory0.byteLength === 0) {
+        cachedUint8ClampedArrayMemory0 = new Uint8ClampedArray(wasm.memory.buffer);
+    }
+    return cachedUint8ClampedArrayMemory0;
+}
+
 function getObject(idx) { return heap[idx]; }
 
 function handleError(f, args) {
@@ -1310,6 +1441,8 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
+let stack_pointer = 1024;
+
 function takeObject(idx) {
     const ret = getObject(idx);
     dropObject(idx);

package/node-esm/wasm_bg.wasm.d.ts

@@ -37,8 +37,12 @@ export const quill_open: (a: number, b: number, c: number) => void;
 export const quill_render: (a: number, b: number, c: number, d: number) => void;
 export const quillmark_new: () => number;
 export const quillmark_quill: (a: number, b: number, c: number) => void;
+export const rendersession_backendId: (a: number, b: number) => void;
 export const rendersession_pageCount: (a: number) => number;
+export const rendersession_pageSize: (a: number, b: number, c: number) => void;
+export const rendersession_paint: (a: number, b: number, c: number, d: number, e: number) => void;
 export const rendersession_render: (a: number, b: number, c: number) => void;
+export const rendersession_warnings: (a: number) => number;
 export const lut_inverse_interp16: (a: number, b: number, c: number) => number;
 export const qcms_profile_precache_output_transform: (a: number) => void;
 export const qcms_white_point_sRGB: (a: number) => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillmark/wasm",
-  "version": "0.66.1",
+  "version": "0.67.0",
   "description": "WebAssembly bindings for quillmark",
   "type": "module",
   "license": "MIT OR Apache-2.0",