@canvist/web 0.0.0-stage → 0.2.0

package/wasm/canvist_web.js

@@ -0,0 +1,1175 @@
+/* @ts-self-types="./canvist_web.d.ts" */
+
+/**
+ * One editor on one canvas.
+ */
+export class WebEditor {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WebEditorFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_webeditor_free(ptr, 0);
+    }
+    /**
+     * Body text's CSS `font` shorthand and colour, as `[font, color]`, for
+     * text the host draws over the canvas in the document's style, such as
+     * a placeholder.
+     * @returns {string[]}
+     */
+    bodyStyle() {
+        const ret = wasm.webeditor_bodyStyle(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Whether the named command would apply. Nothing changes.
+     * @param {string} name
+     * @param {string} args
+     * @returns {boolean}
+     */
+    can(name, args) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(args, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_can(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * The rectangle of a caret at `path` and `offset` (UTF-16 code units),
+     * in document coordinates as `[x, y, width, height]`, or an empty array
+     * when the document has no such position or it is not laid out. Hosts
+     * draw collaborators' carets with it.
+     * @param {Uint32Array} path
+     * @param {number} offset
+     * @returns {Float32Array}
+     */
+    caretRectAt(path, offset) {
+        const ptr0 = passArray32ToWasm0(path, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_caretRectAt(this.__wbg_ptr, ptr0, len0, offset);
+        var v2 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v2;
+    }
+    /**
+     * The caret's rectangle in document coordinates as `[x, y, width,
+     * height]`, or an empty array when the selection is not a caret. Hosts
+     * place IME windows and scroll the caret into view with it.
+     * @returns {Float32Array}
+     */
+    caretRect() {
+        const ret = wasm.webeditor_caretRect(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * The rectangles of the characters in UTF-16 range `start..end` of the
+     * head's text block, as `[x, y, width, height]` per character in
+     * document coordinates, for placing IME candidate windows.
+     * @param {number} start
+     * @param {number} end
+     * @returns {Float32Array}
+     */
+    characterBounds(start, end) {
+        const ret = wasm.webeditor_characterBounds(this.__wbg_ptr, start, end);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Commit the composition as `text`.
+     * @param {string} text
+     * @returns {boolean}
+     */
+    commitComposition(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_commitComposition(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * The selection as `[html, text]` for the clipboard, or empty when
+     * nothing is selected.
+     * @returns {string[]}
+     */
+    copySelection() {
+        const ret = wasm.webeditor_copySelection(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Cut the selection, returning it as [`WebEditor::copy_selection`]
+     * does.
+     * @returns {string[]}
+     */
+    cutSelection() {
+        const ret = wasm.webeditor_cutSelection(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Drop content at `(x, y)`: `html` when the source offered it, otherwise
+     * `text`. With `moving`, the content is this editor's own selection,
+     * dragged: it leaves its old place. A drop inside the dragged selection
+     * does nothing.
+     * @param {number} x
+     * @param {number} y
+     * @param {string | null | undefined} html
+     * @param {string} text
+     * @param {boolean} moving
+     * @returns {boolean}
+     */
+    dropAt(x, y, html, text, moving) {
+        var ptr0 = isLikeNone(html) ? 0 : passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_dropAt(this.__wbg_ptr, x, y, ptr0, len0, ptr1, len1, moving);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * The text an `EditContext` edits: the text block holding the
+     * selection's head, and the selection within it in UTF-16 code units, as
+     * `[text, start, end]`. A selection reaching into another block is
+     * clamped to this one. Empty when the head is not in a text block.
+     * @returns {[text: string, start: number, end: number] | []}
+     */
+    editContextState() {
+        const ret = wasm.webeditor_editContextState(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * The document as `format`.
+     * @param {string} format
+     * @returns {string}
+     */
+    export(format) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.webeditor_export(this.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * Font faces of `families` finished loading: forget only the
+     * measurements of fonts that list one of them, so the blocks using them
+     * lay out again on the next frame. Returns how many measured blocks were
+     * invalidated.
+     * @param {string[]} families
+     * @returns {number}
+     */
+    fontsLoaded(families) {
+        const ptr0 = passArrayJsValueToWasm0(families, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_fontsLoaded(this.__wbg_ptr, ptr0, len0);
+        return ret >>> 0;
+    }
+    /**
+     * The CSS `font` shorthand of every font the layout has used, indexed
+     * by font id.
+     * @returns {string[]}
+     */
+    fonts() {
+        const ret = wasm.webeditor_fonts(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Forget every measurement, as when the device pixel ratio changes:
+     * browsers round font metrics to device pixels, so line positions can
+     * move. Blocks lay out again as they come into view.
+     */
+    forgetMeasurements() {
+        wasm.webeditor_forgetMeasurements(this.__wbg_ptr);
+    }
+    /**
+     * Lay out the viewport and paint whatever changed since the last frame.
+     * Returns what it did as `[height, shift, laidOut, measured, drawn,
+     * full, painted]`: `height` is the document's height in CSS px, `shift`
+     * how far content at the viewport's top moved (add it to the scroll
+     * position), and the flags are 0 or 1.
+     * @returns {Float64Array}
+     */
+    frame() {
+        const ret = wasm.webeditor_frame(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * The whole document laid out, as JSON: block rectangles, caret stops,
+     * and text runs (see the parity tests). Lays out every block first.
+     * @returns {string}
+     */
+    geometry() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.webeditor_geometry(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Lay out text in `families` but draw it invisibly, as browsers do
+     * during a `font-display` block period. Pass an empty list once the
+     * faces load or the period ends.
+     * @param {string[]} families
+     */
+    hideFamilies(families) {
+        const ptr0 = passArrayJsValueToWasm0(families, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.webeditor_hideFamilies(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Server-rendered HTML for the document at the current width, as
+     * `[fragment, stylesheet]`: what SSR sends down, and what the
+     * accessibility mirror shows.
+     * @returns {string[]}
+     */
+    html() {
+        const ret = wasm.webeditor_html(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]);
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * Replace the selection with `text`, running input rules as typing
+     * does. Returns whether anything changed.
+     * @param {string} text
+     * @returns {boolean}
+     */
+    insertText(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_insertText(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Whether the document is a single empty text block, as a new one is.
+     * Hosts show a placeholder then.
+     * @returns {boolean}
+     */
+    isEmpty() {
+        const ret = wasm.webeditor_isEmpty(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Whether `(x, y)` is inside a non-empty selection, where a press starts
+     * dragging the selection rather than selecting.
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean}
+     */
+    isInSelection(x, y) {
+        const ret = wasm.webeditor_isInSelection(this.__wbg_ptr, x, y);
+        return ret !== 0;
+    }
+    /**
+     * Run the key binding for `key`, a DOM `KeyboardEvent.key`, with
+     * `modifiers` (bits: 1 Shift, 2 Ctrl, 4 Alt, 8 Meta). Returns whether a
+     * binding applied; when none did, the host lets the browser handle the
+     * key.
+     * @param {string} key
+     * @param {number} modifiers
+     * @returns {boolean}
+     */
+    keyDown(key, modifiers) {
+        const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_keyDown(this.__wbg_ptr, ptr0, len0, modifiers);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Replace the document with `input` read as `format` (`json`, `html`,
+     * `markdown`, or `text`).
+     * @param {string} format
+     * @param {string} input
+     */
+    load(format, input) {
+        const ptr0 = passStringToWasm0(format, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(input, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_load(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * An editor painting on `canvas`, measuring through `measurer`, with the
+     * named extensions and JSON `options` (see `@canvist/web`'s
+     * `EditorOptions`).
+     * @param {HTMLCanvasElement} canvas
+     * @param {HostMeasurer} measurer
+     * @param {string[]} extensions
+     * @param {string} options
+     */
+    constructor(canvas, measurer, extensions, options) {
+        const ptr0 = passArrayJsValueToWasm0(extensions, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_new(canvas, measurer, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        WebEditorFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Paste HTML over the selection.
+     * Excessive nesting throws a `parse` error without changing the document.
+     * @param {string} html
+     * @returns {boolean}
+     */
+    pasteHtml(html) {
+        const ptr0 = passStringToWasm0(html, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_pasteHtml(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Paste plain text over the selection; paste rules apply.
+     * @param {string} text
+     * @returns {boolean}
+     */
+    pasteText(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_pasteText(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Press the pointer at document coordinates `(x, y)`. One click places
+     * the caret, or extends the selection with `extend`; two select a word
+     * and three the whole text block, and dragging afterwards extends by
+     * that unit.
+     * @param {number} x
+     * @param {number} y
+     * @param {boolean} extend
+     * @param {number} clicks
+     * @returns {boolean}
+     */
+    pointerDown(x, y, extend, clicks) {
+        const ret = wasm.webeditor_pointerDown(this.__wbg_ptr, x, y, extend, clicks);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Move a pressed pointer to `(x, y)`, extending the selection from the
+     * press.
+     * @param {number} x
+     * @param {number} y
+     * @returns {boolean}
+     */
+    pointerMove(x, y) {
+        const ret = wasm.webeditor_pointerMove(this.__wbg_ptr, x, y);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Release the pointer.
+     */
+    pointerUp() {
+        wasm.webeditor_pointerUp(this.__wbg_ptr);
+    }
+    /**
+     * Answer the query an extension registered as `name`, as JSON.
+     * @param {string} name
+     * @param {string} args
+     * @returns {string}
+     */
+    query(name, args) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(args, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.webeditor_query(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * Redo the last undone change.
+     * @returns {boolean}
+     */
+    redo() {
+        const ret = wasm.webeditor_redo(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Replace UTF-16 range `start..end` of the head's text block with
+     * `text`, as an input method or the platform's text input does. A
+     * replacement at a caret is typing, so input rules apply.
+     * @param {number} start
+     * @param {number} end
+     * @param {string} text
+     * @returns {boolean}
+     */
+    replaceText(start, end, text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_replaceText(this.__wbg_ptr, start, end, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Size the canvas: `width` and `height` in CSS pixels, `scale` device
+     * pixels per CSS pixel, and the backing store in device pixels. The
+     * document is laid out to `width`.
+     * @param {number} width
+     * @param {number} height
+     * @param {number} scale
+     * @param {number} pixel_width
+     * @param {number} pixel_height
+     */
+    resize(width, height, scale, pixel_width, pixel_height) {
+        wasm.webeditor_resize(this.__wbg_ptr, width, height, scale, pixel_width, pixel_height);
+    }
+    /**
+     * Run the command an extension registered as `name`, with JSON `args`
+     * (`null` for none). Returns whether it applied.
+     * @param {string} name
+     * @param {string} args
+     * @returns {boolean}
+     */
+    run(name, args) {
+        const ptr0 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(args, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_run(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Select from (`anchor_path`, `anchor_offset`) to (`head_path`,
+     * `head_offset`). Offsets count UTF-16 code units.
+     * @param {Uint32Array} anchor_path
+     * @param {number} anchor_offset
+     * @param {Uint32Array} head_path
+     * @param {number} head_offset
+     */
+    select(anchor_path, anchor_offset, head_path, head_offset) {
+        const ptr0 = passArray32ToWasm0(anchor_path, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray32ToWasm0(head_path, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_select(this.__wbg_ptr, ptr0, len0, anchor_offset, ptr1, len1, head_offset);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * The smallest rectangle around the selection in document coordinates,
+     * as `[x, y, width, height]`: the caret's rectangle for a caret, and
+     * empty while the selection is not laid out. Hosts anchor menus to it.
+     * @returns {Float32Array}
+     */
+    selectionBounds() {
+        const ret = wasm.webeditor_selectionBounds(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * The anchor and head as JSON positions, or `null` for a block
+     * selection.
+     * @returns {string}
+     */
+    selection() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.webeditor_selection(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Snap border widths down to `scale` device pixels per CSS pixel, as
+     * this browser draws them, or not at all when `scale` is not positive.
+     * @param {number} scale
+     */
+    setBorderScale(scale) {
+        wasm.webeditor_setBorderScale(this.__wbg_ptr, scale);
+    }
+    /**
+     * Blink the caret.
+     * @param {boolean} on
+     */
+    setCaretOn(on) {
+        wasm.webeditor_setCaretOn(this.__wbg_ptr, on);
+    }
+    /**
+     * Show `text` as IME preedit text at the selection, replacing any
+     * earlier preedit.
+     * @param {string} text
+     * @returns {boolean}
+     */
+    setComposition(text) {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_setComposition(this.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * Show or hide the caret: hosts call this on focus and blur.
+     * @param {boolean} focused
+     */
+    setFocused(focused) {
+        wasm.webeditor_setFocused(this.__wbg_ptr, focused);
+    }
+    /**
+     * Snap text baselines and rectangle edges to the grid the browser
+     * snaps DOM content to: `"device"` pixels, or `"css"` pixels for
+     * Chromium laying out in CSS units on a high-density screen.
+     * @param {string} grid
+     */
+    setPixelGrid(grid) {
+        const ptr0 = passStringToWasm0(grid, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.webeditor_setPixelGrid(this.__wbg_ptr, ptr0, len0);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * Scroll so document coordinate `top` is at the canvas's top edge.
+     * @param {number} top
+     */
+    setTop(top) {
+        wasm.webeditor_setTop(this.__wbg_ptr, top);
+    }
+    /**
+     * Measurement and cache statistics as JSON: cache hits and misses,
+     * cached bytes per font, and how many segments and batches the browser
+     * measured. The host derives the hit rate, so no float is formatted here
+     * (see `canvist_layout::css_number`).
+     * @returns {string}
+     */
+    stats() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.webeditor_stats(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The whole document as an SVG image painted from the same display
+     * list as the canvas. Lays out every block first.
+     * @returns {string}
+     */
+    svg() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.webeditor_svg(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * Undo the last change. A shared document undoes only this editor's
+     * own changes.
+     * @returns {boolean}
+     */
+    undo() {
+        const ret = wasm.webeditor_undo(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+}
+if (Symbol.dispose) WebEditor.prototype[Symbol.dispose] = WebEditor.prototype.free;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
+            const obj = arg1;
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_addFont_7bf9358d0c77aed6: function(arg0, arg1, arg2, arg3) {
+            arg0.addFont(arg1 >>> 0, getStringFromWasm0(arg2, arg3));
+        },
+        __wbg_arcTo_a1ca709a1aae1a9b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            arg0.arcTo(arg1, arg2, arg3, arg4, arg5);
+        }, arguments); },
+        __wbg_beginPath_8598d895c13f1c86: function(arg0) {
+            arg0.beginPath();
+        },
+        __wbg_clip_275e70d2dc182fec: function(arg0) {
+            arg0.clip();
+        },
+        __wbg_closePath_355eb6da179dd9c2: function(arg0) {
+            arg0.closePath();
+        },
+        __wbg_fillRect_0ef59adb9acb7d06: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.fillRect(arg1, arg2, arg3, arg4);
+        },
+        __wbg_fillText_1bcec8b81ad73bd0: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.fillText(getStringFromWasm0(arg1, arg2), arg3, arg4);
+        }, arguments); },
+        __wbg_fill_fc5e02a06cc26e92: function(arg0) {
+            arg0.fill();
+        },
+        __wbg_getContext_051324720aa5b7e8: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.getContext(getStringFromWasm0(arg1, arg2), arg3);
+            return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+        }, arguments); },
+        __wbg_instanceof_CanvasRenderingContext2d_769208c72dcbf5e6: function(arg0) {
+            let result;
+            try {
+                result = arg0 instanceof CanvasRenderingContext2D;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_lineTo_63fac7d60279d95e: function(arg0, arg1, arg2) {
+            arg0.lineTo(arg1, arg2);
+        },
+        __wbg_measure_79e75cf23afa247f: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) {
+            const ret = arg1.measure(getArrayU32FromWasm0(arg2, arg3), getArrayU32FromWasm0(arg4, arg5), getArrayF32FromWasm0(arg6, arg7), getArrayU32FromWasm0(arg8, arg9), getStringFromWasm0(arg10, arg11), getArrayU32FromWasm0(arg12, arg13));
+            const ptr1 = passArrayF32ToWasm0(ret, wasm.__wbindgen_malloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_moveTo_037e3deefec91ae1: function(arg0, arg1, arg2) {
+            arg0.moveTo(arg1, arg2);
+        },
+        __wbg_new_343a093a3c2ffb4e: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_617a8cdb8bb1130e: function() {
+            const ret = new Object();
+            return ret;
+        },
+        __wbg_new_ee2291f50781bf1d: function() {
+            const ret = new Array();
+            return ret;
+        },
+        __wbg_now_aa4ccb83129e9e55: function() {
+            const ret = Date.now();
+            return ret;
+        },
+        __wbg_paintFont_f6833c16ddedaff0: function(arg0, arg1, arg2) {
+            const ret = arg1.paintFont(arg2 >>> 0);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
+        __wbg_quadraticCurveTo_4f57843d21c4f90d: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.quadraticCurveTo(arg1, arg2, arg3, arg4);
+        },
+        __wbg_rect_c6f60004ffec8f09: function(arg0, arg1, arg2, arg3, arg4) {
+            arg0.rect(arg1, arg2, arg3, arg4);
+        },
+        __wbg_restore_c93ba7571816b182: function(arg0) {
+            arg0.restore();
+        },
+        __wbg_save_f32554f1747071d1: function(arg0) {
+            arg0.save();
+        },
+        __wbg_setTransform_fa787a8f0adc1ade: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            arg0.setTransform(arg1, arg2, arg3, arg4, arg5, arg6);
+        }, arguments); },
+        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(arg0, arg1, arg2);
+            return ret;
+        }, arguments); },
+        __wbg_set_alpha_15af6d7f9268a627: function(arg0, arg1) {
+            arg0.alpha = arg1 !== 0;
+        },
+        __wbg_set_direction_7ceac10a3a56e7ab: function(arg0, arg1, arg2) {
+            arg0.direction = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_fillStyle_a2961b4d44e572af: function(arg0, arg1, arg2) {
+            arg0.fillStyle = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_font_1f60a05a2544a2ff: function(arg0, arg1, arg2) {
+            arg0.font = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_font_kerning_e22d5e53e0b49b4a: function(arg0, arg1, arg2) {
+            arg0.fontKerning = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_font_variant_caps_fddb2612d001f247: function(arg0, arg1, arg2) {
+            arg0.fontVariantCaps = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_height_c9789c1c77eaedff: function(arg0, arg1) {
+            arg0.height = arg1 >>> 0;
+        },
+        __wbg_set_letter_spacing_a9766069411bd841: function(arg0, arg1, arg2) {
+            arg0.letterSpacing = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_lineCap_c9b7bdd3b7f5ce74: function(arg0, arg1, arg2) {
+            arg0.lineCap = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_lineJoin_c1780f2096e6f970: function(arg0, arg1, arg2) {
+            arg0.lineJoin = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_lineWidth_cc15473552c60c9c: function(arg0, arg1) {
+            arg0.lineWidth = arg1;
+        },
+        __wbg_set_name_2c630595dc90a7aa: function(arg0, arg1, arg2) {
+            arg0.name = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_strokeStyle_d51608fa918b53d4: function(arg0, arg1, arg2) {
+            arg0.strokeStyle = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_textAlign_1bda1733d57574ed: function(arg0, arg1, arg2) {
+            arg0.textAlign = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_textBaseline_d5ba548751584f49: function(arg0, arg1, arg2) {
+            arg0.textBaseline = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_text_rendering_111c051258ca1e75: function(arg0, arg1, arg2) {
+            arg0.textRendering = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_width_b0e1267db4b196b5: function(arg0, arg1) {
+            arg0.width = arg1 >>> 0;
+        },
+        __wbg_set_word_spacing_0d1d87f6d472beac: function(arg0, arg1, arg2) {
+            arg0.wordSpacing = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_stroke_385d731098398489: function(arg0) {
+            arg0.stroke();
+        },
+        __wbindgen_generic_0000000000000001: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return ret;
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return ret;
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./canvist_web_bg.js": import0,
+    };
+}
+
+const WebEditorFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_webeditor_free(ptr, 1));
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+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;
+}
+
+let cachedFloat32ArrayMemory0 = null;
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+let cachedFloat64ArrayMemory0 = null;
+function getFloat64ArrayMemory0() {
+    if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
+        cachedFloat64ArrayMemory0 = new Float64Array(wasm.memory.buffer);
+    }
+    return cachedFloat64ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayF32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getFloat32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+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;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+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));
+}
+
+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
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
+    cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('canvist_web_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };