@quillmark/wasm 0.11.0

package/README.md

@@ -0,0 +1,176 @@
+# Quillmark WASM
+
+WebAssembly bindings for the Quillmark markdown rendering engine.
+
+## Overview
+
+This crate provides WASM bindings for Quillmark, enabling use in web browsers, Node.js, and other JavaScript/TypeScript environments. All data exchange uses JSON serialization, and JavaScript is responsible for all I/O operations.
+
+## Building
+
+### For Web (bundler)
+
+```bash
+wasm-pack build --target bundler --scope quillmark
+```
+
+### For Node.js
+
+```bash
+wasm-pack build --target nodejs --scope quillmark
+```
+
+### All targets
+
+```bash
+bash scripts/build-wasm.sh
+```
+
+## Testing
+
+Minimal smoke tests validate the core WASM functionality:
+
+```bash
+# Build WASM module first
+bash scripts/build-wasm.sh
+
+# Run tests
+cd quillmark-wasm
+npm install
+npm test
+```
+
+The test suite includes:
+- `basic.test.js` - Core WASM API functionality tests
+- `tests/usaf_memo.test.js` - Smoke test that verifies WASM PDF output is functionally identical to native cargo output for the `usaf_memo` example (Typst backend)
+- `tests/usaf_form_8.test.js` - Smoke test that verifies WASM PDF output is byte-for-byte identical to native cargo output for the `usaf_form_8` example (Acroform backend)
+
+## Usage
+
+```typescript
+import { Quillmark } from '@quillmark-test/wasm';
+
+// Step 1: Parse markdown
+const markdown = `---
+title: My Document
+author: Alice
+QUILL: my-quill
+---
+
+# Hello World
+
+This is my document.
+`;
+
+const parsed = Quillmark.parseMarkdown(markdown);
+
+// Step 2: Create engine and register Quill
+const engine = new Quillmark();
+
+const quillJson = {
+  files: {
+    'Quill.toml': { 
+      contents: '[Quill]\nname = "my-quill"\nbackend = "typst"\nglue_file = "glue.typ"\ndescription = "My template"\n' 
+    },
+    'glue.typ': { 
+      contents: '= {{ title }}\n\n{{ body | Content }}' 
+    }
+  }
+};
+
+engine.registerQuill(quillJson);
+
+// Step 3: Get Quill info (optional)
+const info = engine.getQuillInfo('my-quill');
+console.log('Supported formats:', info.supportedFormats);
+console.log('Field schemas:', info.fieldSchemas);
+
+// Step 4: Render
+const result = engine.render(parsed, { format: 'pdf' });
+
+// Access the PDF bytes
+const pdfArtifact = result.artifacts[0];
+const blob = new Blob([pdfArtifact.bytes], { type: pdfArtifact.mimeType });
+const url = URL.createObjectURL(blob);
+window.open(url);
+```
+
+## API
+
+The `Quillmark` class provides the following methods:
+
+### Workflow Methods
+
+The main workflow for rendering documents:
+
+- `static parseMarkdown(markdown)` - Parse markdown into a ParsedDocument (Step 1)
+- `registerQuill(quillJson)` - Register a Quill template bundle from JSON (Step 2)
+- `getQuillInfo(name)` - Get shallow Quill metadata and configuration options (Step 3)
+- `render(parsedDoc, options)` - Render a ParsedDocument to final artifacts (Step 4)
+
+### Utility Methods
+
+Additional methods for managing the engine and debugging:
+
+- `new Quillmark()` - Create a new engine instance
+- `processGlue(quillName, markdown)` - Debug helper that processes markdown through the template engine and returns the intermediate template source code (e.g., Typst, LaTeX) without compiling to final artifacts. Useful for inspecting template output during development.
+- `listQuills()` - List all registered Quill names
+- `unregisterQuill(name)` - Unregister a Quill to free memory
+
+### Render Options
+
+```typescript
+{
+  format?: 'pdf' | 'svg' | 'txt',  // Output format (default: 'pdf')
+  assets?: Record<string, Uint8Array>,  // Additional assets to inject as plain object (not Map)
+  quillName?: string  // Override quill_tag from ParsedDocument
+}
+```
+
+### ParsedDocument
+
+Returned by `parseMarkdown()`:
+
+```typescript
+{
+  fields: object,  // YAML frontmatter fields
+  quillTag?: string  // Value of QUILL field (if present)
+}
+```
+
+### QuillInfo
+
+Returned by `getQuillInfo()`:
+
+```typescript
+{
+  name: string,
+  backend: string,  // e.g., "typst"
+  metadata: object,  // Quill metadata from Quill.toml
+  example?: string,  // Example markdown (if available)
+  fieldSchemas: object,  // Field schema definitions
+  supportedFormats: Array<'pdf' | 'svg' | 'txt'>  // Formats this backend supports
+}
+```
+
+## WASM Boundary Types
+
+Data crossing the JavaScript ↔ WebAssembly boundary:
+
+- **Enums**: Serialized as lowercase strings (`"pdf"`, `"svg"`, `"txt"`)
+- **Binary data**: `Vec<u8>` maps to `Uint8Array`
+- **Collections**: `Vec<T>` maps to JS arrays; object types use plain JS objects `{}`
+- **Option**: `Option<T>` maps to `T | null`
+- **Errors**: Thrown as exceptions using `SerializableDiagnostic` from core, containing structured diagnostic information (severity, message, location, hint, source chain)
+
+## Design Principles
+
+- **JSON-Only Data Exchange**: All structured data uses `serde-wasm-bindgen`
+- **JavaScript Handles I/O**: WASM layer only handles rendering
+- **Synchronous Operations**: Rendering is fast enough (<100ms typically)
+- **No File System Abstractions**: JavaScript prepares all data
+- **Error Delegation**: Error handling delegated to core types (`SerializableDiagnostic`) for consistency with Python bindings
+
+## License
+
+Licensed under the Apache License, Version 2.0.

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@quillmark/wasm",
+  "version": "0.11.0",
+  "description": "WebAssembly bindings for quillmark",
+  "type": "module",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nibsbin/quillmark"
+  },
+  "files": [
+    "wasm_bg.wasm",
+    "wasm_bg.js",
+    "wasm_bg.wasm.d.ts",
+    "wasm.js",
+    "wasm.d.ts"
+  ],
+  "main": "./wasm.js",
+  "module": "./wasm.js",
+  "types": "./wasm.d.ts",
+  "exports": {
+    ".": {
+      "types": "./wasm.d.ts",
+      "import": "./wasm.js",
+      "default": "./wasm.js"
+    }
+  },
+  "sideEffects": [
+    "./wasm.js"
+  ]
+}

package/wasm.d.ts

@@ -0,0 +1,115 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * Initialize the WASM module with panic hooks for better error messages
+ */
+export function init(): void;
+export type OutputFormat = "pdf" | "svg" | "txt";
+
+export type Severity = "error" | "warning" | "note";
+
+export interface Location {
+    file: string;
+    line: number;
+    column: number;
+}
+
+export interface Diagnostic {
+    severity: Severity;
+    code?: string;
+    message: string;
+    location?: Location;
+    hint?: string;
+    sourceChain: string[];
+}
+
+export interface Artifact {
+    format: OutputFormat;
+    bytes: Uint8Array;
+    mimeType: string;
+}
+
+export interface RenderResult {
+    artifacts: Artifact[];
+    warnings: Diagnostic[];
+    outputFormat: OutputFormat;
+    renderTimeMs: number;
+}
+
+export interface QuillInfo {
+    name: string;
+    backend: string;
+    metadata: Record<string, any>;
+    example?: string;
+    schema: Record<string, any>;
+    defaults: Record<string, any>;
+    examples: Record<string, any[]>;
+    supportedFormats: OutputFormat[];
+}
+
+export interface ParsedDocument {
+    fields: Record<string, any>;
+    quillTag: string;
+}
+
+export interface RenderOptions {
+    format?: OutputFormat;
+    assets?: Record<string, Uint8Array | number[]>;
+    quillName?: string;
+}
+
+/**
+ * Quillmark WASM Engine
+ *
+ * Create once, register Quills, render markdown. That's it.
+ */
+export class Quillmark {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * JavaScript constructor: `new Quillmark()`
+   */
+  constructor();
+  /**
+   * Parse markdown into a ParsedDocument
+   *
+   * This is the first step in the workflow. The returned ParsedDocument contains
+   * the parsed YAML frontmatter fields and the quill_tag (from QUILL field or "__default__").
+   */
+  static parseMarkdown(markdown: string): ParsedDocument;
+  /**
+   * Register a Quill template bundle
+   *
+   * Accepts either a JSON string or a JsValue object representing the Quill file tree.
+   * Validation happens automatically on registration.
+   */
+  registerQuill(quill_json: any): QuillInfo;
+  /**
+   * Get shallow information about a registered Quill
+   *
+   * This returns metadata, backend info, field schemas, and supported formats
+   * that consumers need to configure render options for the next step.
+   */
+  getQuillInfo(name: string): QuillInfo;
+  /**
+   * Process markdown through template engine (debugging)
+   *
+   * Returns template source code (Typst, LaTeX, etc.)
+   */
+  processPlate(quill_name: string, markdown: string): string;
+  /**
+   * Render a ParsedDocument to final artifacts (PDF, SVG, TXT)
+   *
+   * Uses the Quill specified in options.quill_name if provided,
+   * otherwise infers it from the ParsedDocument's quill_tag field.
+   */
+  render(parsed_wasm: ParsedDocument, opts: RenderOptions): RenderResult;
+  /**
+   * List registered Quill names
+   */
+  listQuills(): string[];
+  /**
+   * Unregister a Quill (free memory)
+   */
+  unregisterQuill(name: string): void;
+}

package/wasm.js

@@ -0,0 +1,5 @@
+import * as wasm from "./wasm_bg.wasm";
+export * from "./wasm_bg.js";
+import { __wbg_set_wasm } from "./wasm_bg.js";
+__wbg_set_wasm(wasm);
+wasm.__wbindgen_start();

package/wasm_bg.js

@@ -0,0 +1,748 @@
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}
+
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let heap = new Array(128).fill(undefined);
+
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export_2(addHeapObject(e));
+    }
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function dropObject(idx) {
+    if (idx < 132) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(takeObject(mem.getUint32(i, true)));
+    }
+    return result;
+}
+/**
+ * Initialize the WASM module with panic hooks for better error messages
+ */
+export function init() {
+    wasm.init();
+}
+
+const QuillmarkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_quillmark_free(ptr >>> 0, 1));
+/**
+ * Quillmark WASM Engine
+ *
+ * Create once, register Quills, render markdown. That's it.
+ */
+export class Quillmark {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QuillmarkFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_quillmark_free(ptr, 0);
+    }
+    /**
+     * JavaScript constructor: `new Quillmark()`
+     */
+    constructor() {
+        const ret = wasm.quillmark_new();
+        this.__wbg_ptr = ret >>> 0;
+        QuillmarkFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Parse markdown into a ParsedDocument
+     *
+     * This is the first step in the workflow. The returned ParsedDocument contains
+     * the parsed YAML frontmatter fields and the quill_tag (from QUILL field or "__default__").
+     * @param {string} markdown
+     * @returns {ParsedDocument}
+     */
+    static parseMarkdown(markdown) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(markdown, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.quillmark_parseMarkdown(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Register a Quill template bundle
+     *
+     * Accepts either a JSON string or a JsValue object representing the Quill file tree.
+     * Validation happens automatically on registration.
+     * @param {any} quill_json
+     * @returns {QuillInfo}
+     */
+    registerQuill(quill_json) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quillmark_registerQuill(retptr, this.__wbg_ptr, addHeapObject(quill_json));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Get shallow information about a registered Quill
+     *
+     * This returns metadata, backend info, field schemas, and supported formats
+     * that consumers need to configure render options for the next step.
+     * @param {string} name
+     * @returns {QuillInfo}
+     */
+    getQuillInfo(name) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.quillmark_getQuillInfo(retptr, this.__wbg_ptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Process markdown through template engine (debugging)
+     *
+     * Returns template source code (Typst, LaTeX, etc.)
+     * @param {string} quill_name
+     * @param {string} markdown
+     * @returns {string}
+     */
+    processPlate(quill_name, markdown) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(quill_name, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(markdown, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.quillmark_processPlate(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+            var ptr3 = r0;
+            var len3 = r1;
+            if (r3) {
+                ptr3 = 0; len3 = 0;
+                throw takeObject(r2);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export_3(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Render a ParsedDocument to final artifacts (PDF, SVG, TXT)
+     *
+     * Uses the Quill specified in options.quill_name if provided,
+     * otherwise infers it from the ParsedDocument's quill_tag field.
+     * @param {ParsedDocument} parsed_wasm
+     * @param {RenderOptions} opts
+     * @returns {RenderResult}
+     */
+    render(parsed_wasm, opts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quillmark_render(retptr, this.__wbg_ptr, addHeapObject(parsed_wasm), addHeapObject(opts));
+            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);
+        }
+    }
+    /**
+     * List registered Quill names
+     * @returns {string[]}
+     */
+    listQuills() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.quillmark_listQuills(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayJsValueFromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export_3(r0, r1 * 4, 4);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Unregister a Quill (free memory)
+     * @param {string} name
+     */
+    unregisterQuill(name) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.quillmark_unregisterQuill(this.__wbg_ptr, ptr0, len0);
+    }
+}
+if (Symbol.dispose) Quillmark.prototype[Symbol.dispose] = Quillmark.prototype.free;
+
+export function __wbg_Error_e17e777aac105295(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_String_eecc4a11987127d6(arg0, arg1) {
+    const ret = String(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg_call_13410aac570ffff7() { return handleError(function (arg0, arg1) {
+    const ret = getObject(arg0).call(getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_done_75ed0ee6dd243d9d(arg0) {
+    const ret = getObject(arg0).done;
+    return ret;
+};
+
+export function __wbg_entries_2be2f15bd5554996(arg0) {
+    const ret = Object.entries(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_export_3(deferred0_0, deferred0_1, 1);
+    }
+};
+
+export function __wbg_getRandomValues_1c61fac11405ffdc() { return handleError(function (arg0, arg1) {
+    globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+}, arguments) };
+
+export function __wbg_getTime_6bb3f64e0f18f817(arg0) {
+    const ret = getObject(arg0).getTime();
+    return ret;
+};
+
+export function __wbg_getUTCDate_e0a363240ba1c112(arg0) {
+    const ret = getObject(arg0).getUTCDate();
+    return ret;
+};
+
+export function __wbg_getUTCFullYear_811e319dd2642ac0(arg0) {
+    const ret = getObject(arg0).getUTCFullYear();
+    return ret;
+};
+
+export function __wbg_getUTCMonth_ed74da16cf6f6c98(arg0) {
+    const ret = getObject(arg0).getUTCMonth();
+    return ret;
+};
+
+export function __wbg_get_0da715ceaecea5c8(arg0, arg1) {
+    const ret = getObject(arg0)[arg1 >>> 0];
+    return addHeapObject(ret);
+};
+
+export function __wbg_get_458e874b43b18b25() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(getObject(arg0), getObject(arg1));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_getwithrefkey_6550b2c093d2eb18(arg0, arg1) {
+    const ret = getObject(arg0)[getObject(arg1)];
+    return addHeapObject(ret);
+};
+
+export function __wbg_instanceof_ArrayBuffer_67f3012529f6a2dd(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+export function __wbg_instanceof_Uint8Array_9a8378d955933db7(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+export function __wbg_isArray_030cce220591fb41(arg0) {
+    const ret = Array.isArray(getObject(arg0));
+    return ret;
+};
+
+export function __wbg_isSafeInteger_1c0d1af5542e102a(arg0) {
+    const ret = Number.isSafeInteger(getObject(arg0));
+    return ret;
+};
+
+export function __wbg_iterator_f370b34483c71a1c() {
+    const ret = Symbol.iterator;
+    return addHeapObject(ret);
+};
+
+export function __wbg_length_186546c51cd61acd(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+};
+
+export function __wbg_length_6bb7e81f9d7713e4(arg0) {
+    const ret = getObject(arg0).length;
+    return ret;
+};
+
+export function __wbg_new0_b0a0a38c201e6df5() {
+    const ret = new Date();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_19c25a3f2fa63a02() {
+    const ret = new Object();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_1f3a344cf3123716() {
+    const ret = new Array();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_2ff1f68f3676ea53() {
+    const ret = new Map();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_5a2ae4557f92b50e(arg0) {
+    const ret = new Date(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_638ebfaedbf32a5e(arg0) {
+    const ret = new Uint8Array(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_8a6f238a6ece86ea() {
+    const ret = new Error();
+    return addHeapObject(ret);
+};
+
+export function __wbg_next_5b3530e612fde77d(arg0) {
+    const ret = getObject(arg0).next;
+    return addHeapObject(ret);
+};
+
+export function __wbg_next_692e82279131b03c() { return handleError(function (arg0) {
+    const ret = getObject(arg0).next();
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_now_1e80617bcee43265() {
+    const ret = Date.now();
+    return ret;
+};
+
+export function __wbg_prototypesetcall_3d4a26c1ed734349(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
+};
+
+export function __wbg_set_3807d5f0bfc24aa7(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+};
+
+export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+};
+
+export function __wbg_set_90f6c0f7bd8c0415(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+};
+
+export function __wbg_set_b7f1cf4fae26fe2a(arg0, arg1, arg2) {
+    const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+};
+
+export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg_stringify_b98c93d0a190446a() { return handleError(function (arg0) {
+    const ret = JSON.stringify(getObject(arg0));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_value_dd9372230531eade(arg0) {
+    const ret = getObject(arg0).value;
+    return addHeapObject(ret);
+};
+
+export function __wbg_wbindgenbigintgetasi64_ac743ece6ab9bba1(arg0, arg1) {
+    const v = getObject(arg1);
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+export function __wbg_wbindgenbooleanget_3fe6f642c7d97746(arg0) {
+    const v = getObject(arg0);
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+};
+
+export function __wbg_wbindgendebugstring_99ef257a3ddda34d(arg0, arg1) {
+    const ret = debugString(getObject(arg1));
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg_wbindgenin_d7a1ee10933d2d55(arg0, arg1) {
+    const ret = getObject(arg0) in getObject(arg1);
+    return ret;
+};
+
+export function __wbg_wbindgenisbigint_ecb90cc08a5a9154(arg0) {
+    const ret = typeof(getObject(arg0)) === 'bigint';
+    return ret;
+};
+
+export function __wbg_wbindgenisfunction_8cee7dce3725ae74(arg0) {
+    const ret = typeof(getObject(arg0)) === 'function';
+    return ret;
+};
+
+export function __wbg_wbindgenisobject_307a53c6bd97fbf8(arg0) {
+    const val = getObject(arg0);
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+export function __wbg_wbindgenisstring_d4fa939789f003b0(arg0) {
+    const ret = typeof(getObject(arg0)) === 'string';
+    return ret;
+};
+
+export function __wbg_wbindgenisundefined_c4b71d073b92f3c5(arg0) {
+    const ret = getObject(arg0) === undefined;
+    return ret;
+};
+
+export function __wbg_wbindgenjsvaleq_e6f2ad59ccae1b58(arg0, arg1) {
+    const ret = getObject(arg0) === getObject(arg1);
+    return ret;
+};
+
+export function __wbg_wbindgenjsvallooseeq_9bec8c9be826bed1(arg0, arg1) {
+    const ret = getObject(arg0) == getObject(arg1);
+    return ret;
+};
+
+export function __wbg_wbindgennumberget_f74b4c7525ac05cb(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+export function __wbg_wbindgenstringget_0f16a6ddddef376f(arg0, arg1) {
+    const obj = getObject(arg1);
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_0, wasm.__wbindgen_export_1);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg_wbindgenthrow_451ec1a8469d7eb6(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_9ae0607507abb057(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_object_clone_ref(arg0) {
+    const ret = getObject(arg0);
+    return addHeapObject(ret);
+};
+
+export function __wbindgen_object_drop_ref(arg0) {
+    takeObject(arg0);
+};
+

package/wasm_bg.wasm.d.ts

@@ -0,0 +1,32 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const __wbg_quillmark_free: (a: number, b: number) => void;
+export const quillmark_new: () => number;
+export const quillmark_parseMarkdown: (a: number, b: number, c: number) => void;
+export const quillmark_registerQuill: (a: number, b: number, c: number) => void;
+export const quillmark_getQuillInfo: (a: number, b: number, c: number, d: number) => void;
+export const quillmark_processPlate: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+export const quillmark_render: (a: number, b: number, c: number, d: number) => void;
+export const quillmark_listQuills: (a: number, b: number) => void;
+export const quillmark_unregisterQuill: (a: number, b: number, c: number) => void;
+export const init: () => void;
+export const qcms_profile_is_bogus: (a: number) => number;
+export const qcms_white_point_sRGB: (a: number) => void;
+export const qcms_profile_precache_output_transform: (a: number) => void;
+export const qcms_transform_data_rgb_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
+export const qcms_transform_data_rgba_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
+export const qcms_transform_data_bgra_out_lut_precache: (a: number, b: number, c: number, d: number) => void;
+export const qcms_transform_data_rgb_out_lut: (a: number, b: number, c: number, d: number) => void;
+export const qcms_transform_data_rgba_out_lut: (a: number, b: number, c: number, d: number) => void;
+export const qcms_transform_data_bgra_out_lut: (a: number, b: number, c: number, d: number) => void;
+export const qcms_transform_release: (a: number) => void;
+export const qcms_enable_iccv4: () => void;
+export const lut_interp_linear16: (a: number, b: number, c: number) => number;
+export const lut_inverse_interp16: (a: number, b: number, c: number) => number;
+export const __wbindgen_export_0: (a: number, b: number) => number;
+export const __wbindgen_export_1: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export_2: (a: number) => void;
+export const __wbindgen_export_3: (a: number, b: number, c: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_start: () => void;