@quillmark/wasm 0.129.0 → 0.131.0

package/render/wasm.js

@@ -441,8 +441,11 @@ export class Document {
         return Document.__wrap(ret);
     }
     /**
-     * Storage version this build writes via [`toStored`](Document::to_stored). The
-     * tag advances only when the wire format changes, not on every release.
+     * The newest storage version this build writes via
+     * [`toStored`](Document::to_stored): a document spelling a font mark, a
+     * `table` element, a merged table cell or a table head 0.130 cannot draw
+     * carries it, every other the tag before it, which a 0.130 build reads. The tag advances only when the wire format changes, not on
+     * every release.
      * @returns {string}
      */
     static currentStorageVersion() {
@@ -978,9 +981,9 @@ export class Document {
     }
     /**
      * Read the storage version tag from a raw storage DTO string without a full
-     * parse, or `undefined`. Unknown future versions come back as-is, which
-     * distinguishes "build too old" from "payload corrupt" when `fromStored`
-     * throws. This is the storage version, not a field schema, though the JSON
+     * parse, or `undefined`. A tag this build does not read, newer or retired,
+     * comes back as-is, which tells a version mismatch from a corrupt payload
+     * when `fromStored` throws. This is the storage version, not a field schema, though the JSON
      * key is spelled `"schema"`: that is the DTO's serde tag.
      * @param {string} json
      * @returns {string | undefined}
@@ -1203,11 +1206,51 @@ export class Engine {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_engine_free(ptr, 0);
     }
-    constructor() {
-        const ret = wasm.engine_new();
-        this.__wbg_ptr = ret;
-        EngineFinalization.register(this, this.__wbg_ptr, this);
-        return this;
+    /**
+     * The text faces a `font_family` mark may set in a session of `quill`:
+     * the host library's, in library order.
+     * @param {Quill} quill
+     * @returns {FontFace[]}
+     */
+    fontFaces(quill) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(quill, Quill);
+            wasm.engine_fontFaces(retptr, this.__wbg_ptr, quill.__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);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * An engine whose sessions also set text in `fonts`, the host's font
+     * library: each a `.ttf`, `.otf`, `.ttc` or `.otc` file, parsed once
+     * here. A file in another format throws `engine::font_unsupported`, and
+     * one holding no readable face `engine::font_unreadable`.
+     * @param {Uint8Array[] | undefined} fonts
+     */
+    constructor(fonts) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.engine_new(retptr, addHeapObject(fonts));
+            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;
+            EngineFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
     }
     /**
      * Open a live render session for `doc` against `quill`'s backend, on the
@@ -2452,6 +2495,9 @@ function __wbg_get_imports() {
             const ret = Reflect.getPrototypeOf(getObject(arg0));
             return addHeapObject(ret);
         }, arguments); },
+        __wbg_getRandomValues_436a51d0629d84e1: function() { return handleError(function (arg0, arg1) {
+            globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
+        }, arguments); },
         __wbg_get_658f6698067d9515: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(getObject(arg0), getObject(arg1));
             return addHeapObject(ret);
@@ -2603,6 +2649,10 @@ function __wbg_get_imports() {
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
         },
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
+            const ret = getObject(arg0).push(getObject(arg1));
+            return ret;
+        },
         __wbg_putImageData_11570c06086c9e05: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             getObject(arg0).putImageData(getObject(arg1), arg2, arg3);
         }, arguments); },

package/render/wasm_bg.wasm.d.ts

@@ -52,7 +52,8 @@ export const document_toAnnotatedMarkdown: (a: number, b: number) => void;
 export const document_toMarkdown: (a: number, b: number) => void;
 export const document_toStored: (a: number, b: number) => void;
 export const document_warnings: (a: number, b: number) => void;
-export const engine_new: () => number;
+export const engine_fontFaces: (a: number, b: number, c: number) => void;
+export const engine_new: (a: number, b: number) => void;
 export const engine_open: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const engine_render: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
 export const engine_supportedFormats: (a: number, b: number, c: number) => void;

package/runtime/runtime.d.ts

@@ -415,6 +415,31 @@ export interface EngineOptions {
 	 * `"typst"` and `"acroform"` to the bundled render build.
 	 */
 	backends?: Record<string, BackendDescriptor>;
+
+	/**
+	 * The host's font library: each a `.ttf`, `.otf`, `.ttc` or `.otc` file,
+	 * whose faces set only text a `font_family` mark sets. The bytes are
+	 * copied at construction, cross into the render build once, when it loads,
+	 * and are parsed there once. A file it refuses rejects every verb that
+	 * needs that build, the first and each later one, with the same error:
+	 * `engine::font_unsupported` for another format, `engine::font_unreadable`
+	 * for a file holding no readable face. A value that is not an array of
+	 * `Uint8Array` throws at construction.
+	 */
+	fonts?: Uint8Array[];
+}
+
+/**
+ * One face a session sets text in, with what an editor needs for an
+ * `@font-face` rule: the family, the CSS weight and style, and the font file.
+ * `index` is the face's place in `data` where the file is a collection.
+ */
+export interface FontFace {
+	family: string;
+	weight: number;
+	style: 'normal' | 'italic' | 'oblique';
+	index: number;
+	data: Uint8Array;
 }
 
 /**
@@ -485,6 +510,15 @@ export declare class Engine {
 	 * backend binary or cloning the quill. Async for API stability.
 	 */
 	supportedFormats(quill: Quill): Promise<OutputFormat[]>;
+
+	/**
+	 * The text faces a `font_family` mark may set in a session of `quill`: the
+	 * host library's, in the order of `fonts`. A quill's own fonts and the
+	 * embedded fallback set its plate, never a mark. Loads the backend and
+	 * clones the quill as `open` does; a backend that reads no fonts answers
+	 * `[]`.
+	 */
+	fontFaces(quill: Quill): Promise<FontFace[]>;
 }
 
 /**

package/runtime/runtime.js

@@ -470,10 +470,22 @@ export class Engine {
 	 */
 	/** load → Promise<build module>, memoized so each build loads once. */
 	#modules = new Map();
-	/** load → that build's engine instance (the WASM backend registry). */
+	/**
+	 * load → `{ engine }`, that build's engine instance (the WASM backend
+	 * registry), or `{ refused }`, the error its construction threw. A refusal
+	 * is the font library's, which every retry would parse and refuse again.
+	 */
 	#engines = new Map();
 	/** backendId → descriptor `{ load, formats }`. */
 	#loaders;
+	/**
+	 * The host's font library, copied at construction and handed to each
+	 * build's engine as it loads; `null` once every build has had it.
+	 * @type {Uint8Array[] | null}
+	 */
+	#fonts;
+	/** How many distinct builds the loaders name. */
+	#builds;
 	/**
 	 * load → WeakMap<canonical Quill, build-memory clone>, caching the
 	 * expensive materialization. WeakMap so dropping the canonical quill makes
@@ -486,10 +498,15 @@ export class Engine {
 	 * `load` must resolve to a READY module: a registrant shipping its own
 	 * `--target web` build instantiates inside the thunk, and more than one
 	 * `Engine` may call it, so memoize (the built-ins do, at module scope).
-	 * @param {{ backends?: Record<string, { load: () => Promise<unknown>, formats: string[] }> }} [options]
+	 * @param {{ backends?: Record<string, { load: () => Promise<unknown>, formats: string[] }>, fonts?: Uint8Array[] }} [options]
 	 */
 	constructor(options) {
-		rejectUnknownKeys(options, ['backends'], 'Engine options');
+		rejectUnknownKeys(options, ['backends', 'fonts'], 'Engine options');
+		const fonts = options?.fonts ?? [];
+		if (!Array.isArray(fonts) || !fonts.every((font) => font instanceof Uint8Array)) {
+			throw new Error('Engine: `fonts` must be an array of Uint8Array.');
+		}
+		this.#fonts = fonts.map((font) => font.slice());
 		const merged = { ...DEFAULT_BACKENDS, ...(options?.backends ?? {}) };
 		/** @type {Record<string, { load: () => Promise<unknown>, formats: string[] }>} */
 		const loaders = {};
@@ -497,6 +514,7 @@ export class Engine {
 			loaders[id] = validateBackend(id, entry);
 		}
 		this.#loaders = loaders;
+		this.#builds = new Set(Object.values(loaders).map((descriptor) => descriptor.load)).size;
 	}
 
 	/**
@@ -554,12 +572,18 @@ export class Engine {
 		}
 		const mod = await modPromise;
 
-		let engine = this.#engines.get(load);
-		if (!engine) {
-			engine = new mod.Engine();
-			this.#engines.set(load, engine);
+		let built = this.#engines.get(load);
+		if (!built) {
+			try {
+				built = { engine: new mod.Engine(this.#fonts) };
+			} catch (refused) {
+				built = { refused };
+			}
+			this.#engines.set(load, built);
+			if (this.#engines.size === this.#builds) this.#fonts = null;
 		}
-		return { mod, engine };
+		if ('refused' in built) throw built.refused;
+		return { mod, engine: built.engine };
 	}
 
 	/**
@@ -658,6 +682,36 @@ export class Engine {
 		);
 	}
 
+	/**
+	 * Run `fn` against `quill`'s build-memory clone, `quill` snapshotted before
+	 * the first await as `#withClones` snapshots it.
+	 * @param {string} method the caller's name, for the rejection message
+	 * @param {Quill} quill
+	 * @param {(ctx: { engine: any, quill: any }) => any} fn
+	 */
+	async #withQuill(method, quill, fn) {
+		const backendId = this.#backendOf(quill, method);
+		const quillTree = this.#quillClones.get(this.#descriptorFor(backendId).load)?.has(quill)
+			? null
+			: quill.toTree();
+		const { mod, engine } = await this.#resolveBackend(backendId);
+		try {
+			return fn({ engine, quill: this.#cachedQuillClone(mod, backendId, quill, quillTree) });
+		} catch (err) {
+			throw backendTrap(err);
+		}
+	}
+
+	/**
+	 * @param {Quill} quill
+	 * @returns {Promise<import('./runtime.d.ts').FontFace[]>}
+	 */
+	async fontFaces(quill) {
+		return this.#withQuill('engine.fontFaces(quill)', quill, ({ engine, quill: q }) =>
+			typeof engine.fontFaces === 'function' ? engine.fontFaces(q) : []
+		);
+	}
+
 	/**
 	 * @param {Quill} quill
 	 * @returns {Promise<void>}