wongtty 0.0.0-stage → 0.0.2

package/dist/xterm_web.js

@@ -0,0 +1,4063 @@
+/* @ts-self-types="./xterm_web.d.ts" */
+import { Terminal as Terminal2 } from './index.js';
+
+
+/**
+ * xterm.js `IBufferCell`.
+ */
+export class BufferCell {
+    static __wrap(ptr) {
+        const obj = Object.create(BufferCell.prototype);
+        obj.__wbg_ptr = ptr;
+        BufferCellFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BufferCellFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_buffercell_free(ptr, 0);
+    }
+    /**
+     * The cell text; `''` for an erased cell and the right half of a wide character, like xterm.js.
+     * @returns {string}
+     */
+    getChars() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.buffercell_getChars(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_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * The code point (0 for an erased cell), or the last UTF-16 unit of a cell with combining marks, like xterm.js.
+     * @returns {number}
+     */
+    getCode() {
+        const ret = wasm.buffercell_getCode(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * 2 for a wide character, 0 for its right half, else 1.
+     * @returns {number}
+     */
+    getWidth() {
+        const ret = wasm.buffercell_getWidth(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    isBlink() {
+        const ret = wasm.buffercell_isBlink(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    isBold() {
+        const ret = wasm.buffercell_isBold(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    isDim() {
+        const ret = wasm.buffercell_isDim(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    isInverse() {
+        const ret = wasm.buffercell_isInverse(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    isInvisible() {
+        const ret = wasm.buffercell_isInvisible(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    isItalic() {
+        const ret = wasm.buffercell_isItalic(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    isStrikethrough() {
+        const ret = wasm.buffercell_isStrikethrough(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Any underline style.
+     * @returns {number}
+     */
+    isUnderline() {
+        const ret = wasm.buffercell_isUnderline(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BufferCell.prototype[Symbol.dispose] = BufferCell.prototype.free;
+
+/**
+ * xterm.js `IBufferLine`: a copy of one row.
+ */
+export class BufferLine {
+    static __wrap(ptr) {
+        const obj = Object.create(BufferLine.prototype);
+        obj.__wbg_ptr = ptr;
+        BufferLineFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BufferLineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bufferline_free(ptr, 0);
+    }
+    /**
+     * Cell `x`, or `undefined` outside the line. `cell` is accepted for xterm.js compatibility and not reused:
+     * use the returned cell.
+     * @param {number} x
+     * @param {IBufferCell} [cell]
+     * @returns {BufferCell | undefined}
+     */
+    getCell(x, cell) {
+        const ret = wasm.bufferline_getCell(this.__wbg_ptr, x, isLikeNone(cell) ? 0 : addHeapObject(cell));
+        return ret === 0 ? undefined : BufferCell.__wrap(ret);
+    }
+    /**
+     * Whether this line continues the previous one (soft wrap).
+     * @returns {boolean}
+     */
+    get isWrapped() {
+        const ret = wasm.bufferline_is_wrapped(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.bufferline_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Like xterm.js: erased cells are spaces, `trimRight` drops trailing erased cells (not typed spaces), a wide
+     * character covers two columns, and a range that starts on its right half gets a space there. Unlike
+     * xterm.js, columns outside the line are clamped (xterm.js pads them).
+     * @param {boolean | null} [trimRight]
+     * @param {number | null} [startColumn]
+     * @param {number | null} [endColumn]
+     * @returns {string}
+     */
+    translateToString(trimRight, startColumn, endColumn) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bufferline_translateToString(retptr, this.__wbg_ptr, isLikeNone(trimRight) ? 0xFFFFFF : trimRight ? 1 : 0, !isLikeNone(startColumn), isLikeNone(startColumn) ? 0 : startColumn, !isLikeNone(endColumn), isLikeNone(endColumn) ? 0 : endColumn);
+            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_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) BufferLine.prototype[Symbol.dispose] = BufferLine.prototype.free;
+
+/**
+ * xterm.js `IBufferNamespace`.
+ */
+export class BufferNamespace {
+    static __wrap(ptr) {
+        const obj = Object.create(BufferNamespace.prototype);
+        obj.__wbg_ptr = ptr;
+        BufferNamespaceFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BufferNamespaceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_buffernamespace_free(ptr, 0);
+    }
+    /**
+     * The buffer on screen now; it keeps its type when the program switches screens.
+     * @returns {BufferView}
+     */
+    get active() {
+        const ret = wasm.buffernamespace_active(this.__wbg_ptr);
+        return BufferView.__wrap(ret);
+    }
+    /**
+     * @returns {BufferView}
+     */
+    get alternate() {
+        const ret = wasm.buffernamespace_alternate(this.__wbg_ptr);
+        return BufferView.__wrap(ret);
+    }
+    /**
+     * @returns {BufferView}
+     */
+    get normal() {
+        const ret = wasm.buffernamespace_normal(this.__wbg_ptr);
+        return BufferView.__wrap(ret);
+    }
+    /**
+     * Fires with the new active buffer when the program enters or leaves the alternate screen.
+     * @returns {IEvent<IBuffer>}
+     */
+    get onBufferChange() {
+        const ret = wasm.buffernamespace_on_buffer_change(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) BufferNamespace.prototype[Symbol.dispose] = BufferNamespace.prototype.free;
+
+/**
+ * xterm.js `IBuffer`, one of the two screens.
+ */
+export class BufferView {
+    static __wrap(ptr) {
+        const obj = Object.create(BufferView.prototype);
+        obj.__wbg_ptr = ptr;
+        BufferViewFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BufferViewFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bufferview_free(ptr, 0);
+    }
+    /**
+     * Line at the top of the screen: the scrollback length (the host's lines included in viewport-only mode).
+     * @returns {number}
+     */
+    get baseY() {
+        const ret = wasm.bufferview_base_y(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Cursor column. At the right edge it stays on the last column where xterm.js reports `cols` (the engine
+     * keeps the pending wrap to itself).
+     * @returns {number}
+     */
+    get cursorX() {
+        const ret = wasm.bufferview_cursor_x(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Cursor row on the screen (0 is the top screen row, whatever the scroll position).
+     * @returns {number}
+     */
+    get cursorY() {
+        const ret = wasm.bufferview_cursor_y(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * A copy of line `y` taken now (xterm.js hands out a live view), or `undefined` outside `0..length`.
+     * @param {number} y
+     * @returns {BufferLine | undefined}
+     */
+    getLine(y) {
+        const ret = wasm.bufferview_getLine(this.__wbg_ptr, y);
+        return ret === 0 ? undefined : BufferLine.__wrap(ret);
+    }
+    /**
+     * An empty cell: no text, width 1.
+     * @returns {BufferCell}
+     */
+    getNullCell() {
+        const ret = wasm.bufferview_getNullCell(this.__wbg_ptr);
+        return BufferCell.__wrap(ret);
+    }
+    /**
+     * @returns {'normal' | 'alternate'}
+     */
+    get type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.bufferview_kind(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_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Scrollback plus screen lines.
+     * @returns {number}
+     */
+    get length() {
+        const ret = wasm.bufferview_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Line shown at the top of the viewport.
+     * @returns {number}
+     */
+    get viewportY() {
+        const ret = wasm.bufferview_viewport_y(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) BufferView.prototype[Symbol.dispose] = BufferView.prototype.free;
+
+/**
+ * xterm.js `IDisposable`. Dropping it on the Rust side does nothing; `dispose()` runs the teardown once.
+ */
+export class Disposable {
+    static __wrap(ptr) {
+        const obj = Object.create(Disposable.prototype);
+        obj.__wbg_ptr = ptr;
+        DisposableFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DisposableFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_disposable_free(ptr, 0);
+    }
+    dispose() {
+        wasm.disposable_dispose(this.__wbg_ptr);
+    }
+}
+if (Symbol.dispose) Disposable.prototype[Symbol.dispose] = Disposable.prototype.free;
+
+/**
+ * Sizes the terminal to its element's parent, like `@xterm/addon-fit`.
+ */
+export class FitAddon {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        FitAddonFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_fitaddon_free(ptr, 0);
+    }
+    /**
+     * Internal: marks the built-in addon for `loadAddon`.
+     * @returns {number}
+     */
+    get __wongttyFitAddon() {
+        const ret = wasm.fitaddon___wongttyFitAddon(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * `terminal.loadAddon(fitAddon)` calls this.
+     * @param {Terminal} terminal
+     */
+    activate(terminal) {
+        _assertClass(terminal, Terminal);
+        wasm.fitaddon_activate(this.__wbg_ptr, terminal.__wbg_ptr);
+    }
+    dispose() {
+        wasm.fitaddon_dispose(this.__wbg_ptr);
+    }
+    /**
+     * Resizes the terminal to `proposeDimensions()`.
+     */
+    fit() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.fitaddon_fit(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+    constructor() {
+        const ret = wasm.fitaddon_new();
+        this.__wbg_ptr = ret;
+        FitAddonFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * The size that fills the parent, `undefined` before `open` or while the cell size is unknown.
+     * @returns {{ cols: number; rows: number } | undefined}
+     */
+    proposeDimensions() {
+        const ret = wasm.fitaddon_proposeDimensions(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) FitAddon.prototype[Symbol.dispose] = FitAddon.prototype.free;
+
+/**
+ * Built-in image addon: `new ImageAddon(options)` takes `@xterm/addon-image`'s options.
+ */
+export class ImageAddon {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ImageAddonFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_imageaddon_free(ptr, 0);
+    }
+    /**
+     * Internal: marks the built-in addon for `loadAddon`.
+     * @returns {number}
+     */
+    get __wongttyImageAddon() {
+        const ret = wasm.imageaddon___wongttyImageAddon(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * `terminal.loadAddon(addon)` calls this.
+     * @param {Terminal} terminal
+     */
+    activate(terminal) {
+        _assertClass(terminal, Terminal);
+        wasm.imageaddon_activate(this.__wbg_ptr, terminal.__wbg_ptr);
+    }
+    /**
+     * Removes the handlers and every image.
+     */
+    dispose() {
+        wasm.imageaddon_dispose(this.__wbg_ptr);
+    }
+    /**
+     * The protocol handlers by name (`'sixel'`, `'iip'`), as `@xterm/addon-image` keeps them.
+     * @returns {Map<string, unknown>}
+     */
+    get _handlers() {
+        const ret = wasm.imageaddon_handlers(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @param {IImageAddonOptions} options
+     */
+    constructor(options) {
+        const ret = wasm.imageaddon_new(isLikeNone(options) ? 0 : addHeapObject(options));
+        this.__wbg_ptr = ret;
+        ImageAddonFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Fires after an image is placed.
+     * @returns {IEvent<void>}
+     */
+    get onImageAdded() {
+        const ret = wasm.imageaddon_on_image_added(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Resets the options sequences change and drops every image (RIS, DECSTR).
+     * @returns {boolean}
+     */
+    reset() {
+        const ret = wasm.imageaddon_reset(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @param {boolean} value
+     */
+    set showPlaceholder(value) {
+        wasm.imageaddon_set_show_placeholder(this.__wbg_ptr, value);
+    }
+    /**
+     * @param {number} limit
+     */
+    set storageLimit(limit) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.imageaddon_set_storage_limit(retptr, this.__wbg_ptr, limit);
+            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);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    get showPlaceholder() {
+        const ret = wasm.imageaddon_show_placeholder(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Storage limit in MB; -1 before `loadAddon`.
+     * @returns {number}
+     */
+    get storageLimit() {
+        const ret = wasm.imageaddon_storage_limit(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * MB the images hold; -1 before `loadAddon`.
+     * @returns {number}
+     */
+    get storageUsage() {
+        const ret = wasm.imageaddon_storage_usage(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) ImageAddon.prototype[Symbol.dispose] = ImageAddon.prototype.free;
+
+/**
+ * xterm.js `IMarker`.
+ */
+export class Marker {
+    static __wrap(ptr) {
+        const obj = Object.create(Marker.prototype);
+        obj.__wbg_ptr = ptr;
+        MarkerFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MarkerFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_marker_free(ptr, 0);
+    }
+    /**
+     * Removes the marker and fires `onDispose`, like xterm.js; again does nothing.
+     */
+    dispose() {
+        wasm.marker_dispose(this.__wbg_ptr);
+    }
+    /**
+     * Unique among the terminal's markers (xterm.js numbers markers across all terminals).
+     * @returns {number}
+     */
+    get id() {
+        const ret = wasm.marker_id(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get isDisposed() {
+        const ret = wasm.marker_is_disposed(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * The buffer line (0 is the oldest scrollback line), -1 once disposed.
+     * @returns {number}
+     */
+    get line() {
+        const ret = wasm.marker_line(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * Fires once when the marker is disposed; a listener added after that is never called.
+     * @returns {IEvent<void>}
+     */
+    get onDispose() {
+        const ret = wasm.marker_on_dispose(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) Marker.prototype[Symbol.dispose] = Marker.prototype.free;
+
+/**
+ * xterm.js `IParser`: CSI, DCS and OSC handlers. `true` from a handler skips the older handlers and the default
+ * action; `false` falls through to them; a `Promise<boolean>` holds the write queue until it settles. `write()`
+ * from inside a handler is parsed after the data being parsed. A throwing or rejecting handler counts as false
+ * and its error is thrown again on a later task.
+ */
+export class Parser {
+    static __wrap(ptr) {
+        const obj = Object.create(Parser.prototype);
+        obj.__wbg_ptr = ptr;
+        ParserFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ParserFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_parser_free(ptr, 0);
+    }
+    /**
+     * @param {IFunctionIdentifier} id
+     * @param {(params: IParams) => boolean | Promise<boolean>} callback
+     * @returns {Disposable}
+     */
+    registerCsiHandler(id, callback) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.parser_registerCsiHandler(retptr, this.__wbg_ptr, addHeapObject(id), addHeapObject(callback));
+            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 Disposable.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {IFunctionIdentifier} id
+     * @param {(data: string, param: IParams) => boolean | Promise<boolean>} callback
+     * @returns {Disposable}
+     */
+    registerDcsHandler(id, callback) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.parser_registerDcsHandler(retptr, this.__wbg_ptr, addHeapObject(id), addHeapObject(callback));
+            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 Disposable.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * `ident` is the number before the first `;`; the handler gets the rest.
+     * @param {number} ident
+     * @param {(data: string) => boolean | Promise<boolean>} callback
+     * @returns {Disposable}
+     */
+    registerOscHandler(ident, callback) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.parser_registerOscHandler(retptr, this.__wbg_ptr, ident, addHeapObject(callback));
+            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 Disposable.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) Parser.prototype[Symbol.dispose] = Parser.prototype.free;
+
+/**
+ * xterm.js `@xterm/addon-search`, built in: load it with `terminal.loadAddon(new SearchAddon())`.
+ */
+export class SearchAddon {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SearchAddonFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_searchaddon_free(ptr, 0);
+    }
+    /**
+     * Internal: marks the built-in addon for `loadAddon`.
+     * @returns {number}
+     */
+    get __wongttySearchAddon() {
+        const ret = wasm.searchaddon___wongttySearchAddon(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * `terminal.loadAddon(searchAddon)` calls this.
+     * @param {Terminal} terminal
+     */
+    activate(terminal) {
+        _assertClass(terminal, Terminal);
+        wasm.searchaddon_activate(this.__wbg_ptr, terminal.__wbg_ptr);
+    }
+    /**
+     * Clears the active match's decoration (meant for the search box's `blur`).
+     */
+    clearActiveDecoration() {
+        wasm.searchaddon_clearActiveDecoration(this.__wbg_ptr);
+    }
+    /**
+     * Clears the decorations and forgets the term, so the next search starts over from the selection start.
+     */
+    clearDecorations() {
+        wasm.searchaddon_clearDecorations(this.__wbg_ptr);
+    }
+    /**
+     * Stops following the terminal and clears the decorations; searching still works, like the addon.
+     */
+    dispose() {
+        wasm.searchaddon_dispose(this.__wbg_ptr);
+    }
+    /**
+     * Selects the next match after the selection (from the top without one), wrapping around, and scrolls it into
+     * view. False when there is none; a bad regular expression throws.
+     * @param {string} term
+     * @param {ISearchOptions} [searchOptions]
+     * @returns {boolean}
+     */
+    findNext(term, searchOptions) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.searchaddon_findNext(retptr, this.__wbg_ptr, addHeapObject(term), addHeapObject(searchOptions));
+            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 r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Like `findNext`, backwards from the selection (from the bottom without one).
+     * @param {string} term
+     * @param {ISearchOptions} [searchOptions]
+     * @returns {boolean}
+     */
+    findPrevious(term, searchOptions) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.searchaddon_findPrevious(retptr, this.__wbg_ptr, addHeapObject(term), addHeapObject(searchOptions));
+            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 r0 !== 0;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {Partial<ISearchAddonOptions>} [options]
+     */
+    constructor(options) {
+        const ret = wasm.searchaddon_new(isLikeNone(options) ? 0 : addHeapObject(options));
+        this.__wbg_ptr = ret;
+        SearchAddonFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {IEvent<void>}
+     */
+    get onAfterSearch() {
+        const ret = wasm.searchaddon_on_after_search(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {IEvent<void>}
+     */
+    get onBeforeSearch() {
+        const ret = wasm.searchaddon_on_before_search(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * With decorations: the active match's index among all matches (-1 if none or past `highlightLimit`) and their
+     * count, after each search.
+     * @returns {IEvent<ISearchResultChangeEvent>}
+     */
+    get onDidChangeResults() {
+        const ret = wasm.searchaddon_on_did_change_results(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) SearchAddon.prototype[Symbol.dispose] = SearchAddon.prototype.free;
+
+export class Terminal {
+    static __wrap(ptr) {
+        const obj = Object.create(Terminal.prototype);
+        obj.__wbg_ptr = ptr;
+        TerminalFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TerminalFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_terminal_free(ptr, 0);
+    }
+    /**
+     * Host rows held for the view in viewport-only mode, 0 otherwise (for tests and the memory bench).
+     * @returns {number}
+     */
+    _historyCacheSize() {
+        const ret = wasm.terminal__historyCacheSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * State for the tests: the image tiles of the last frame (`[row, col, id, tile]`), this terminal's images and
+     * the page's (`images`, `pixels`), the GPU textures of images.
+     * @returns {any}
+     */
+    _imageDebug() {
+        const ret = wasm.terminal__imageDebug(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Test-only: the renderer's internal state.
+     * @returns {any}
+     */
+    _rendererDebug() {
+        const ret = wasm.terminal__rendererDebug(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Internal: replaces highlight layer `layer` with `{ row, start, end, background?, foreground?, border?,
+     * underline? }` entries in viewport cells.
+     * @param {string} layer
+     * @param {any} highlights
+     */
+    _setHighlights(layer, highlights) {
+        const ptr0 = passStringToWasm0(layer, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.terminal__setHighlights(this.__wbg_ptr, ptr0, len0, addHeapObject(highlights));
+    }
+    /**
+     * Internal: the selection the renderer draws, `{ start: [col, row], end: [col, row], columnSelect }` in
+     * viewport cells, or `undefined`.
+     * @param {any} selection
+     */
+    _setRendererSelection(selection) {
+        wasm.terminal__setRendererSelection(this.__wbg_ptr, addHeapObject(selection));
+    }
+    /**
+     * Bytes that rebuild this screen, scrollback included, in a fresh terminal of the same size (the engine's
+     * `ansiSnapshot`; replaces `@xterm/addon-serialize`). `{ scrollback: 0, excludeModes: true }` paints just the
+     * screen it shows (a cold frame), as `serialize` with the same options does.
+     * @param {AnsiSnapshotOptions} [options]
+     * @returns {AnsiSnapshot}
+     */
+    ansiSnapshot(options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_ansiSnapshot(retptr, this.__wbg_ptr, addHeapObject(options));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * `handler` sees every keydown, keypress and keyup first; returning false stops the terminal from handling it.
+     * @param {CustomKeyEventHandler} handler
+     */
+    attachCustomKeyEventHandler(handler) {
+        wasm.terminal_attachCustomKeyEventHandler(this.__wbg_ptr, addHeapObject(handler));
+    }
+    /**
+     * `handler` sees every wheel event the mouse handles first; returning false keeps it from being reported or
+     * sent as arrow keys.
+     * @param {CustomWheelEventHandler} handler
+     */
+    attachCustomWheelEventHandler(handler) {
+        wasm.terminal_attachCustomWheelEventHandler(this.__wbg_ptr, addHeapObject(handler));
+    }
+    blur() {
+        wasm.terminal_blur(this.__wbg_ptr);
+    }
+    /**
+     * xterm.js `term.buffer`; a new namespace object per read.
+     * @returns {BufferNamespace}
+     */
+    get buffer() {
+        const ret = wasm.terminal_buffer(this.__wbg_ptr);
+        return BufferNamespace.__wrap(ret);
+    }
+    clearSelection() {
+        wasm.terminal_clearSelection(this.__wbg_ptr);
+    }
+    /**
+     * @returns {number}
+     */
+    get cols() {
+        const ret = wasm.terminal_cols(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Cell and canvas size, `undefined` before `open`.
+     * @returns {IRenderDimensions | undefined}
+     */
+    get dimensions() {
+        const ret = wasm.terminal_dimensions(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Drops pending writes without running their callbacks, like xterm.js. Safe to call from any listener.
+     */
+    dispose() {
+        wasm.terminal_dispose(this.__wbg_ptr);
+    }
+    /**
+     * @returns {HTMLElement | undefined}
+     */
+    get element() {
+        const ret = wasm.terminal_element(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    focus() {
+        wasm.terminal_focus(this.__wbg_ptr);
+    }
+    /**
+     * The selection in buffer cells, end exclusive, or `undefined` without one.
+     * @returns {IBufferRange | undefined}
+     */
+    getSelectionPosition() {
+        const ret = wasm.terminal_getSelectionPosition(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The selected text: wrapped rows joined, wide characters once, lines joined with `\n` (`\r\n` on Windows).
+     * @returns {string}
+     */
+    getSelection() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_getSelection(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_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Whether some text is selected.
+     * @returns {boolean}
+     */
+    hasSelection() {
+        const ret = wasm.terminal_hasSelection(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * xterm.js `input` (`CoreTerminal.input`): `data` goes to `onData` as is. With `wasUserInput` (the default) it
+     * counts as typed: it scrolls to the bottom (`scrollOnUserInput`), fires `onUserInput` and clears the selection.
+     * `disableStdin` drops it either way.
+     * @param {string} data
+     * @param {boolean} [wasUserInput]
+     */
+    input(data, wasUserInput) {
+        wasm.terminal_input(this.__wbg_ptr, addHeapObject(data), isLikeNone(wasUserInput) ? 0xFFFFFF : wasUserInput ? 1 : 0);
+    }
+    /**
+     * wongtty API: the kitty keyboard flags the program pushed, read from the engine like `modes` so they are current
+     * right after a write (0 while it pushed none or `vtExtensions.kittyKeyboard` is off).
+     * @returns {number}
+     */
+    get kittyKeyboardFlags() {
+        const ret = wasm.terminal_kitty_keyboard_flags(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Accepts the built-in `FitAddon` (refitted by itself when the cell size changes) and `SearchAddon`, and
+     * absorbs `@xterm/addon-webgl` (and the built-in `WebglAddon`) and `@xterm/addon-unicode11`, whose work is
+     * built in. Any other addon throws.
+     * @param {ITerminalAddon} addon
+     */
+    loadAddon(addon) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_loadAddon(retptr, this.__wbg_ptr, addHeapObject(addon));
+            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);
+        }
+    }
+    /**
+     * The live markers of the active buffer, oldest first, like xterm.js.
+     * @returns {ReadonlyArray<IMarker>}
+     */
+    get markers() {
+        const ret = wasm.terminal_markers(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * A new object per read, like xterm.js. `reverseWraparoundMode` and `win32InputMode` are always false (the
+     * engine has neither).
+     * @returns {IModes}
+     */
+    get modes() {
+        const ret = wasm.terminal_modes(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Throws unless `await init()` has finished.
+     * @param {object | null} [options]
+     */
+    constructor(options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_new(retptr, isLikeNone(options) ? 0 : addHeapObject(options));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0;
+            TerminalFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @returns {IEvent<void>}
+     */
+    get onBell() {
+        const ret = wasm.terminal_on_bell(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {IEvent<string>}
+     */
+    get onBinary() {
+        const ret = wasm.terminal_on_binary(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {IEvent<void>}
+     */
+    get onCursorMove() {
+        const ret = wasm.terminal_on_cursor_move(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Input for the program (keys, paste) and replies to it (status reports).
+     * @returns {IEvent<string>}
+     */
+    get onData() {
+        const ret = wasm.terminal_on_data(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The cell size changed: after a font option, or when fonts finish loading (a loaded fit addon refits then).
+     * @returns {IEvent<IRenderDimensions>}
+     */
+    get onDimensionsChange() {
+        const ret = wasm.terminal_on_dimensions_change(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {IEvent<{ start: number, end: number }>}
+     */
+    get onRender() {
+        const ret = wasm.terminal_on_render(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {IEvent<{ cols: number, rows: number }>}
+     */
+    get onResize() {
+        const ret = wasm.terminal_on_resize(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The new viewport top line (`buffer.active.viewportY`).
+     * @returns {IEvent<number>}
+     */
+    get onScroll() {
+        const ret = wasm.terminal_on_scroll(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Fires when the selection changes: mouse selections when the button is released, the API, and clears by
+     * user input, a resize, a screen switch or a reset (not when trimming moves or drops it, like xterm.js).
+     * @returns {IEvent<void>}
+     */
+    get onSelectionChange() {
+        const ret = wasm.terminal_on_selection_change(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {IEvent<string>}
+     */
+    get onTitleChange() {
+        const ret = wasm.terminal_on_title_change(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * wongtty API: fires just before `onData` for keys, IME, paste and mouse reports, never for replies to the
+     * program.
+     * @returns {IEvent<void>}
+     */
+    get onUserInput() {
+        const ret = wasm.terminal_on_user_input(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @returns {IEvent<void>}
+     */
+    get onWriteParsed() {
+        const ret = wasm.terminal_on_write_parsed(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * @param {HTMLElement} parent
+     */
+    open(parent) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_open(retptr, this.__wbg_ptr, addHeapObject(parent));
+            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);
+        }
+    }
+    /**
+     * `term.options.x = y` and `term.options = { … }` both go through `setOption`.
+     * @returns {ProxyConstructor}
+     */
+    get options() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_options(retptr, this.__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);
+        }
+    }
+    /**
+     * @returns {IParser}
+     */
+    get parser() {
+        const ret = wasm.terminal_parser(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * Sends `data` as if pasted: newlines become CR, bracketed when the program asked for it.
+     * @param {string} data
+     */
+    paste(data) {
+        const ptr0 = passStringToWasm0(data, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.terminal_paste(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * Redraws viewport rows `start`…`end` on the next frame.
+     * @param {number} start
+     * @param {number} end
+     */
+    refresh(start, end) {
+        wasm.terminal_refresh(this.__wbg_ptr, start, end);
+    }
+    /**
+     * Adds a link provider, asked after the OSC 8 links and the providers registered before it; the earliest
+     * provider with a link under the mouse wins and later links that overlap its links are dropped.
+     * @param {ILinkProvider} linkProvider
+     * @returns {Disposable}
+     */
+    registerLinkProvider(linkProvider) {
+        const ret = wasm.terminal_registerLinkProvider(this.__wbg_ptr, addHeapObject(linkProvider));
+        return Disposable.__wrap(ret);
+    }
+    /**
+     * A marker on the cursor line plus `cursorYOffset` of the active buffer. `undefined` for a line outside the
+     * buffer (xterm.js marks those too); non-integers throw like xterm.js.
+     * @param {number | null} [cursorYOffset]
+     * @returns {IMarker}
+     */
+    registerMarker(cursorYOffset) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_registerMarker(retptr, this.__wbg_ptr, !isLikeNone(cursorYOffset), isLikeNone(cursorYOffset) ? 0 : cursorYOffset);
+            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 r0 === 0 ? undefined : Marker.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * wongtty API: drops the kitty keyboard flags the program pushed, on both screens; keys are encoded the legacy
+     * way at once.
+     */
+    resetKittyKeyboard() {
+        wasm.terminal_resetKittyKeyboard(this.__wbg_ptr);
+    }
+    /**
+     * Full reset (RIS), applied at once: a synchronized update ends, writes still queued are parsed afterwards (as
+     * in xterm.js, whose write buffer `reset` leaves alone).
+     */
+    reset() {
+        wasm.terminal_reset(this.__wbg_ptr);
+    }
+    /**
+     * A second resize before the next frame only records the size (`cols`/`rows` report it at once); the frame,
+     * or a write before it, reflows once and fires `onResize` then.
+     * @param {number} cols
+     * @param {number} rows
+     */
+    resize(cols, rows) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_resize(retptr, this.__wbg_ptr, cols, rows);
+            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);
+        }
+    }
+    /**
+     * @returns {number}
+     */
+    get rows() {
+        const ret = wasm.terminal_rows(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * Positive `amount` scrolls down towards the newest output.
+     * @param {number} amount
+     */
+    scrollLines(amount) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_scrollLines(retptr, this.__wbg_ptr, amount);
+            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);
+        }
+    }
+    /**
+     * Scrolls by `pageCount` screens less one row, like xterm.js.
+     * @param {number} pageCount
+     */
+    scrollPages(pageCount) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_scrollPages(retptr, this.__wbg_ptr, pageCount);
+            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);
+        }
+    }
+    scrollToBottom() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_scrollToBottom(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * Scrolls so that buffer line `line` is the top viewport row.
+     * @param {number} line
+     */
+    scrollToLine(line) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_scrollToLine(retptr, this.__wbg_ptr, line);
+            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);
+        }
+    }
+    scrollToTop() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_scrollToTop(retptr, this.__wbg_ptr);
+            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);
+        }
+    }
+    /**
+     * Selects the whole buffer.
+     */
+    selectAll() {
+        wasm.terminal_selectAll(this.__wbg_ptr);
+    }
+    /**
+     * Selects buffer lines `start` to `end`, both included.
+     * @param {number} start
+     * @param {number} end
+     */
+    selectLines(start, end) {
+        wasm.terminal_selectLines(this.__wbg_ptr, start, end);
+    }
+    /**
+     * Selects `length` cells from `column` of buffer line `row`, running on into the next rows. Does nothing
+     * before `open()` (xterm.js throws).
+     * @param {number} column
+     * @param {number} row
+     * @param {number} length
+     */
+    select(column, row, length) {
+        wasm.terminal_select(this.__wbg_ptr, column, row, length);
+    }
+    /**
+     * Viewport-only mode (PRD M4): history older than this terminal's own `scrollback` is read from `provider` as
+     * the view scrolls to it. `null` turns it off. Set it again after a resize, with the host's new `length`.
+     * @param {IHistoryProvider | null} provider
+     */
+    setHistoryProvider(provider) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_setHistoryProvider(retptr, this.__wbg_ptr, addHeapObject(provider));
+            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);
+        }
+    }
+    /**
+     * @param {object} options
+     */
+    set options(options) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.terminal_set_options(retptr, this.__wbg_ptr, addHeapObject(options));
+            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);
+        }
+    }
+    /**
+     * The hidden textarea that takes keyboard and IME input, set by `open`.
+     * @returns {HTMLTextAreaElement | undefined}
+     */
+    get textarea() {
+        const ret = wasm.terminal_textarea(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+    /**
+     * The engine measures widths with the Unicode 11 tables only.
+     * @returns {UnicodeHandling}
+     */
+    get unicode() {
+        const ret = wasm.terminal_unicode(this.__wbg_ptr);
+        return UnicodeHandling.__wrap(ret);
+    }
+    /**
+     * `callback` runs once the engine has parsed `data`; `write('', callback)` waits for earlier writes.
+     * @param {any} data
+     * @param {Function | null} [callback]
+     */
+    write(data, callback) {
+        wasm.terminal_write(this.__wbg_ptr, addHeapObject(data), isLikeNone(callback) ? 0 : addHeapObject(callback));
+    }
+    /**
+     * @param {any} data
+     * @param {Function | null} [callback]
+     */
+    writeln(data, callback) {
+        wasm.terminal_writeln(this.__wbg_ptr, addHeapObject(data), isLikeNone(callback) ? 0 : addHeapObject(callback));
+    }
+}
+if (Symbol.dispose) Terminal.prototype[Symbol.dispose] = Terminal.prototype.free;
+
+/**
+ * `terminal.unicode`: the engine measures widths with the Unicode 11 tables only.
+ */
+export class UnicodeHandling {
+    static __wrap(ptr) {
+        const obj = Object.create(UnicodeHandling.prototype);
+        obj.__wbg_ptr = ptr;
+        UnicodeHandlingFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        UnicodeHandlingFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_unicodehandling_free(ptr, 0);
+    }
+    /**
+     * Always `"11"`; setting another version throws.
+     * @returns {string}
+     */
+    get activeVersion() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.unicodehandling_activeVersion(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_export5(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {string} version
+     */
+    set activeVersion(version) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.unicodehandling_set_activeVersion(retptr, this.__wbg_ptr, addHeapObject(version));
+            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);
+        }
+    }
+    /**
+     * @returns {ReadonlyArray<string>}
+     */
+    get versions() {
+        const ret = wasm.unicodehandling_versions(this.__wbg_ptr);
+        return takeObject(ret);
+    }
+}
+if (Symbol.dispose) UnicodeHandling.prototype[Symbol.dispose] = UnicodeHandling.prototype.free;
+
+/**
+ * `@xterm/addon-web-links`, built in: load it with `terminal.loadAddon(new WebLinksAddon(handler?, options?))`.
+ */
+export class WebLinksAddon {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WebLinksAddonFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_weblinksaddon_free(ptr, 0);
+    }
+    /**
+     * Internal: marks the built-in addon for `loadAddon`.
+     * @returns {number}
+     */
+    get __wongttyWebLinksAddon() {
+        const ret = wasm.weblinksaddon___wongttyWebLinksAddon(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * `terminal.loadAddon(webLinksAddon)` calls this: registers the URL provider.
+     * @param {Terminal} terminal
+     */
+    activate(terminal) {
+        _assertClass(terminal, Terminal);
+        wasm.weblinksaddon_activate(this.__wbg_ptr, terminal.__wbg_ptr);
+    }
+    /**
+     * Removes the URL provider.
+     */
+    dispose() {
+        wasm.weblinksaddon_dispose(this.__wbg_ptr);
+    }
+    /**
+     * `handler` opens a link (a new window without an opener by default); `options.hover`/`leave` follow the mouse
+     * and `options.urlRegex` replaces the URL pattern.
+     * @param {(event: MouseEvent, uri: string) => void} [handler]
+     * @param {ILinkProviderOptions} [options]
+     */
+    constructor(handler, options) {
+        const ret = wasm.weblinksaddon_new(addHeapObject(handler), addHeapObject(options));
+        this.__wbg_ptr = ret;
+        WebLinksAddonFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+}
+if (Symbol.dispose) WebLinksAddon.prototype[Symbol.dispose] = WebLinksAddon.prototype.free;
+
+/**
+ * `@xterm/addon-webgl`, built in: the terminal already draws with WebGL2 (one context per page) and restores a lost
+ * context by itself. Loading this addon, or `@xterm/addon-webgl` itself, only keeps code written for xterm.js working.
+ */
+export class WebglAddon {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WebglAddonFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_webgladdon_free(ptr, 0);
+    }
+    /**
+     * @param {Terminal} _terminal
+     */
+    activate(_terminal) {
+        _assertClass(_terminal, Terminal);
+        wasm.webgladdon_activate(this.__wbg_ptr, _terminal.__wbg_ptr);
+    }
+    /**
+     * Redraws the terminal the addon was loaded into in full (`loadAddon` binds it).
+     */
+    clearTextureAtlas() {
+        wasm.webgladdon_clearTextureAtlas(this.__wbg_ptr);
+    }
+    dispose() {
+        wasm.webgladdon_dispose(this.__wbg_ptr);
+    }
+    /**
+     * `preserveDrawingBuffer` is ignored: the renderer owns its context.
+     * @param {boolean | null} [_preserve_drawing_buffer]
+     */
+    constructor(_preserve_drawing_buffer) {
+        const ret = wasm.webgladdon_new(isLikeNone(_preserve_drawing_buffer) ? 0xFFFFFF : _preserve_drawing_buffer ? 1 : 0);
+        this.__wbg_ptr = ret;
+        WebglAddonFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Never fires: the renderer restores or replaces a lost context by itself.
+     * @param {() => void} _listener
+     * @returns {Disposable}
+     */
+    onContextLoss(_listener) {
+        const ret = wasm.webgladdon_onContextLoss(this.__wbg_ptr, addHeapObject(_listener));
+        return Disposable.__wrap(ret);
+    }
+}
+if (Symbol.dispose) WebglAddon.prototype[Symbol.dispose] = WebglAddon.prototype.free;
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg_RegExp_018f52b0988db88d: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = RegExp(getObject(arg0), getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg___wbindgen_boolean_get_5b446f51afd21013: function(arg0) {
+            const v = getObject(arg0);
+            const ret = typeof(v) === 'boolean' ? v : undefined;
+            return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+        },
+        __wbg___wbindgen_is_falsy_16bd49b68658263e: function(arg0) {
+            const ret = !getObject(arg0);
+            return ret;
+        },
+        __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'function';
+            return ret;
+        },
+        __wbg___wbindgen_is_null_e343b7d08827ba72: function(arg0) {
+            const ret = getObject(arg0) === null;
+            return ret;
+        },
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
+            const val = getObject(arg0);
+            const ret = typeof(val) === 'object' && val !== null;
+            return ret;
+        },
+        __wbg___wbindgen_is_string_90b56bc79aad6f6c: function(arg0) {
+            const ret = typeof(getObject(arg0)) === 'string';
+            return ret;
+        },
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
+            const ret = getObject(arg0) === undefined;
+            return ret;
+        },
+        __wbg___wbindgen_jsval_eq_02babf21faa37971: function(arg0, arg1) {
+            const ret = getObject(arg0) === getObject(arg1);
+            return ret;
+        },
+        __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(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);
+        },
+        __wbg___wbindgen_rethrow_cb2e88c6b2a16733: function(arg0) {
+            throw takeObject(arg0);
+        },
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
+            const obj = getObject(arg1);
+            const ret = typeof(obj) === 'string' ? obj : undefined;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            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__wbg_cb_unref_dcc1a90847f04c41: function(arg0) {
+            getObject(arg0)._wbg_cb_unref();
+        },
+        __wbg_activeElement_69b55e3697f14d9b: function(arg0) {
+            const ret = getObject(arg0).activeElement;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_activeTexture_11079673eac5c921: function(arg0, arg1) {
+            getObject(arg0).activeTexture(arg1 >>> 0);
+        },
+        __wbg_actualBoundingBoxDescent_dfaf3fa19c2134c9: function(arg0) {
+            const ret = getObject(arg0).actualBoundingBoxDescent;
+            return ret;
+        },
+        __wbg_addEventListener_4d0db17c671ea324: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+        }, arguments); },
+        __wbg_addEventListener_8d3235978b9c69a8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).addEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), getObject(arg4));
+        }, arguments); },
+        __wbg_addMarker_7d5331ae983d07ab: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).addMarker(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_add_005f8aadd043a01c: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).add(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_add_9ceab44da1353b80: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).add(getStringFromWasm0(arg1, arg2));
+        }, arguments); },
+        __wbg_altKey_1e5fe17a42050103: function(arg0) {
+            const ret = getObject(arg0).altKey;
+            return ret;
+        },
+        __wbg_altKey_cfb4c4fab9a7d0d0: function(arg0) {
+            const ret = getObject(arg0).altKey;
+            return ret;
+        },
+        __wbg_ansiSnapshot_127bc0539320706e: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).ansiSnapshot(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_appendChild_fb8c52e7dd8484ea: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).appendChild(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_apply_a910804df6e1e433: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).apply(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_assign_e39d243f5fbe1e2d: function(arg0, arg1) {
+            const ret = Object.assign(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_attachShader_9567ae57af6746d5: function(arg0, arg1, arg2) {
+            getObject(arg0).attachShader(getObject(arg1), getObject(arg2));
+        },
+        __wbg_beginPath_8598d895c13f1c86: function(arg0) {
+            getObject(arg0).beginPath();
+        },
+        __wbg_bezierCurveTo_4e6afc9957d235e6: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            getObject(arg0).bezierCurveTo(arg1, arg2, arg3, arg4, arg5, arg6);
+        },
+        __wbg_bindBuffer_0324f62b876c4403: function(arg0, arg1, arg2) {
+            getObject(arg0).bindBuffer(arg1 >>> 0, getObject(arg2));
+        },
+        __wbg_bindTexture_3cf008f256f3ed99: function(arg0, arg1, arg2) {
+            getObject(arg0).bindTexture(arg1 >>> 0, getObject(arg2));
+        },
+        __wbg_bindVertexArray_f58af0a346185ec5: function(arg0, arg1) {
+            getObject(arg0).bindVertexArray(getObject(arg1));
+        },
+        __wbg_bind_586a4771c616dbe9: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).bind(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_bind_7a91c4a37b5b545a: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).bind(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
+            return addHeapObject(ret);
+        },
+        __wbg_bind_e7f12e49a3040c89: function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).bind(getObject(arg1), getObject(arg2), getObject(arg3));
+            return addHeapObject(ret);
+        },
+        __wbg_blendFunc_589e4252bb396484: function(arg0, arg1, arg2) {
+            getObject(arg0).blendFunc(arg1 >>> 0, arg2 >>> 0);
+        },
+        __wbg_blur_cb8bd1ead8743f99: function() { return handleError(function (arg0) {
+            getObject(arg0).blur();
+        }, arguments); },
+        __wbg_bufferData_5fa44d94fe7a3878: function(arg0, arg1, arg2, arg3) {
+            getObject(arg0).bufferData(arg1 >>> 0, getObject(arg2), arg3 >>> 0);
+        },
+        __wbg_bufferData_ec7957bcbbf38591: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).bufferData(arg1 >>> 0, getArrayU8FromWasm0(arg2, arg3), arg4 >>> 0);
+        },
+        __wbg_buffer_9cb148c510fd44ba: function(arg0) {
+            const ret = getObject(arg0).buffer;
+            return addHeapObject(ret);
+        },
+        __wbg_bufferview_new: function(arg0) {
+            const ret = BufferView.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_button_1aa380c7ca420cd1: function(arg0) {
+            const ret = getObject(arg0).button;
+            return ret;
+        },
+        __wbg_buttons_de1e6c7f6de70736: function(arg0) {
+            const ret = getObject(arg0).buttons;
+            return ret;
+        },
+        __wbg_call_1875a20c43a36133: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_6137034ef55c9d0f: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).call(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_call_939a2607c4484b0b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).call(getObject(arg1), getObject(arg2), getObject(arg3), getObject(arg4));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_cancelAnimationFrame_6484b22d0b6cf249: function(arg0) {
+            cancelAnimationFrame(getObject(arg0));
+        },
+        __wbg_canvas_2b619d4767b78c03: function(arg0) {
+            const ret = getObject(arg0).canvas;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_charCodeAt_bbfbcedfafe34880: function(arg0, arg1) {
+            const ret = getObject(arg0).charCodeAt(arg1 >>> 0);
+            return ret;
+        },
+        __wbg_charCode_6af74268b7f246fd: function(arg0) {
+            const ret = getObject(arg0).charCode;
+            return ret;
+        },
+        __wbg_classList_8a097a4837412bf6: function(arg0) {
+            const ret = getObject(arg0).classList;
+            return addHeapObject(ret);
+        },
+        __wbg_clearRect_a5e36505218c247a: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).clearRect(arg1, arg2, arg3, arg4);
+        },
+        __wbg_clearTimeout_aa8c12f323ab34eb: function(arg0) {
+            clearTimeout(getObject(arg0));
+        },
+        __wbg_clear_fb916dd7a73e3c3f: function(arg0) {
+            getObject(arg0).clear();
+        },
+        __wbg_clientHeight_33dd2a2c8630a1f1: function(arg0) {
+            const ret = getObject(arg0).clientHeight;
+            return ret;
+        },
+        __wbg_clientWidth_08d5512595aacb73: function(arg0) {
+            const ret = getObject(arg0).clientWidth;
+            return ret;
+        },
+        __wbg_clientX_5075231ed45e8ef5: function(arg0) {
+            const ret = getObject(arg0).clientX;
+            return ret;
+        },
+        __wbg_clientY_846c39814ce02ab2: function(arg0) {
+            const ret = getObject(arg0).clientY;
+            return ret;
+        },
+        __wbg_clip_29f22936ddd324c5: function(arg0, arg1) {
+            getObject(arg0).clip(getObject(arg1));
+        },
+        __wbg_clipboardData_0048090643ed57a2: function(arg0) {
+            const ret = getObject(arg0).clipboardData;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_closePath_355eb6da179dd9c2: function(arg0) {
+            getObject(arg0).closePath();
+        },
+        __wbg_close_355afba6ea5ad1ae: function(arg0) {
+            getObject(arg0).close();
+        },
+        __wbg_code_422d539f5d7bacbb: function(arg0, arg1) {
+            const ret = getObject(arg1).code;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_cols_431f50655a4a80d6: function(arg0) {
+            const ret = getObject(arg0).cols;
+            return ret;
+        },
+        __wbg_compileShader_c2b53ff3a8851f60: function(arg0, arg1) {
+            getObject(arg0).compileShader(getObject(arg1));
+        },
+        __wbg_composedPath_ebbc1f73360cd735: function(arg0) {
+            const ret = getObject(arg0).composedPath();
+            return addHeapObject(ret);
+        },
+        __wbg_composed_71392ff44ca88df8: function(arg0) {
+            const ret = getObject(arg0).composed;
+            return ret;
+        },
+        __wbg_concat_8f1c164716380e3e: function(arg0, arg1) {
+            const ret = getObject(arg0).concat(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_confirm_2ec41c041fd93588: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).confirm(getStringFromWasm0(arg1, arg2));
+            return ret;
+        }, arguments); },
+        __wbg_construct_2cc135b78387ed16: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.construct(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_contains_05d0776afca2789a: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).contains(getStringFromWasm0(arg1, arg2));
+            return ret;
+        },
+        __wbg_contains_dd3796baeaeb3211: function(arg0, arg1) {
+            const ret = getObject(arg0).contains(getObject(arg1));
+            return ret;
+        },
+        __wbg_createBuffer_ffe613371d42cfd3: function(arg0) {
+            const ret = getObject(arg0).createBuffer();
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_createElement_74049073a11f9c31: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_createImageBitmap_69996a36c51d409f: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).createImageBitmap(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_createLinearGradient_d67a7d18d11c0b62: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).createLinearGradient(arg1, arg2, arg3, arg4);
+            return addHeapObject(ret);
+        },
+        __wbg_createPattern_94e5692cc458e195: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).createPattern(getObject(arg1), getStringFromWasm0(arg2, arg3));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_createProgram_cbf448e6f18a9402: function(arg0) {
+            const ret = getObject(arg0).createProgram();
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_createShader_6c1a2295587878a5: function(arg0, arg1) {
+            const ret = getObject(arg0).createShader(arg1 >>> 0);
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_createTexture_5f2583508ebe379b: function(arg0) {
+            const ret = getObject(arg0).createTexture();
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_createVertexArray_b223ea69dd08fcab: function(arg0) {
+            const ret = getObject(arg0).createVertexArray();
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_ctrlKey_282349f48e6cb157: function(arg0) {
+            const ret = getObject(arg0).ctrlKey;
+            return ret;
+        },
+        __wbg_ctrlKey_8b5101745e8782fa: function(arg0) {
+            const ret = getObject(arg0).ctrlKey;
+            return ret;
+        },
+        __wbg_currentTarget_de5fa91e460fd474: function(arg0) {
+            const ret = getObject(arg0).currentTarget;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_cursor_80f00d7fc0920afb: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).cursor();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_data_9ce11d34b90054d4: function(arg0, arg1) {
+            const ret = getObject(arg1).data;
+            const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_defaultPrevented_5af41e1dd07ed819: function(arg0) {
+            const ret = getObject(arg0).defaultPrevented;
+            return ret;
+        },
+        __wbg_defaultView_cfaeace4733a17c1: function(arg0) {
+            const ret = getObject(arg0).defaultView;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_defineProperty_363eb34158116b0f: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.defineProperty(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
+        __wbg_deleteBuffer_070e58aaaf2a7a8b: function(arg0, arg1) {
+            getObject(arg0).deleteBuffer(getObject(arg1));
+        },
+        __wbg_deleteProgram_b524b30ad176cdb4: function(arg0, arg1) {
+            getObject(arg0).deleteProgram(getObject(arg1));
+        },
+        __wbg_deleteShader_a70f6cc1918d67eb: function(arg0, arg1) {
+            getObject(arg0).deleteShader(getObject(arg1));
+        },
+        __wbg_deleteTexture_9f42750adb092e4f: function(arg0, arg1) {
+            getObject(arg0).deleteTexture(getObject(arg1));
+        },
+        __wbg_deleteVertexArray_ca9768805d051d49: function(arg0, arg1) {
+            getObject(arg0).deleteVertexArray(getObject(arg1));
+        },
+        __wbg_deltaMode_6280d8266d5520f5: function(arg0) {
+            const ret = getObject(arg0).deltaMode;
+            return ret;
+        },
+        __wbg_deltaX_d330516e89f03877: function(arg0) {
+            const ret = getObject(arg0).deltaX;
+            return ret;
+        },
+        __wbg_deltaY_7abc8fc9878d0002: function(arg0) {
+            const ret = getObject(arg0).deltaY;
+            return ret;
+        },
+        __wbg_deref_ac93ff09826b71e6: function(arg0) {
+            const ret = getObject(arg0).deref();
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_detail_67ecb80fc27bb9cd: function(arg0) {
+            const ret = getObject(arg0).detail;
+            return ret;
+        },
+        __wbg_devicePixelRatio_7d39e9af5448d3d4: function(arg0) {
+            const ret = getObject(arg0).devicePixelRatio;
+            return ret;
+        },
+        __wbg_disable_19fe787eccdf0272: function(arg0, arg1) {
+            getObject(arg0).disable(arg1 >>> 0);
+        },
+        __wbg_displayOffset_ad1884bf30f37e6e: function(arg0) {
+            const ret = getObject(arg0).displayOffset;
+            return ret;
+        },
+        __wbg_disposable_new: function(arg0) {
+            const ret = Disposable.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_dispose_260eb8a9a85af475: function(arg0) {
+            getObject(arg0).dispose();
+        },
+        __wbg_document_9854e03c05fc8834: function(arg0) {
+            const ret = getObject(arg0).document;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_drawElementsInstanced_d7c396aa034159b6: function(arg0, arg1, arg2, arg3, arg4, arg5) {
+            getObject(arg0).drawElementsInstanced(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
+        },
+        __wbg_drawImage_10b40b3262f51daa: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            getObject(arg0).drawImage(getObject(arg1), arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        }, arguments); },
+        __wbg_drawImage_39c26cd632a846aa: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).drawImage(getObject(arg1), arg2, arg3);
+        }, arguments); },
+        __wbg_drawImage_3fed5f1f3393a907: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            getObject(arg0).drawImage(getObject(arg1), arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
+        }, arguments); },
+        __wbg_drawImage_93d4867540340235: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).drawImage(getObject(arg1), arg2, arg3);
+        }, arguments); },
+        __wbg_enableVertexAttribArray_d52693866bc8b8dd: function(arg0, arg1) {
+            getObject(arg0).enableVertexAttribArray(arg1 >>> 0);
+        },
+        __wbg_enable_cb4fc19b51148c37: function(arg0, arg1) {
+            getObject(arg0).enable(arg1 >>> 0);
+        },
+        __wbg_endsWith_5e70b4a30ac04fad: function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).endsWith(getStringFromWasm0(arg1, arg2), arg3);
+            return ret;
+        },
+        __wbg_entries_fb6397112b1de25f: function(arg0) {
+            const ret = Object.entries(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_error_c9cf3fc2064683a9: function(arg0) {
+            console.error(getObject(arg0));
+        },
+        __wbg_exec_a5f4ba02713fbebe: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).exec(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_exec_b101e1149ae0719c: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).exec(getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_fillRect_0ef59adb9acb7d06: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).fillRect(arg1, arg2, arg3, arg4);
+        },
+        __wbg_fillStyle_19e5c12c3020c19c: function(arg0) {
+            const ret = getObject(arg0).fillStyle;
+            return addHeapObject(ret);
+        },
+        __wbg_fillText_1bcec8b81ad73bd0: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).fillText(getStringFromWasm0(arg1, arg2), arg3, arg4);
+        }, arguments); },
+        __wbg_fill_fc5e02a06cc26e92: function(arg0) {
+            getObject(arg0).fill();
+        },
+        __wbg_finishHook_c1f2bb3276198666: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).finishHook(arg1 !== 0);
+        }, arguments); },
+        __wbg_flags_243a6a81580ddf40: function(arg0) {
+            const ret = getObject(arg0).flags;
+            return addHeapObject(ret);
+        },
+        __wbg_flushSync_b37e26a55d119583: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).flushSync();
+            return ret;
+        }, arguments); },
+        __wbg_focus_e1638be0df4aeb8f: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).focus(getObject(arg1));
+        }, arguments); },
+        __wbg_focus_f740d61348f422e7: function() { return handleError(function (arg0) {
+            getObject(arg0).focus();
+        }, arguments); },
+        __wbg_fontBoundingBoxAscent_694ba20be295b1c3: function(arg0) {
+            const ret = getObject(arg0).fontBoundingBoxAscent;
+            return ret;
+        },
+        __wbg_fontBoundingBoxDescent_e0d660bcc3049b29: function(arg0) {
+            const ret = getObject(arg0).fontBoundingBoxDescent;
+            return ret;
+        },
+        __wbg_fonts_74badbc3e3496e66: function(arg0) {
+            const ret = getObject(arg0).fonts;
+            return addHeapObject(ret);
+        },
+        __wbg_fromCharCode_6076dc7ba70a8d8a: function(arg0, arg1) {
+            const ret = String.fromCharCode(...(getArrayU16FromWasm0(arg0, arg1)));
+            return addHeapObject(ret);
+        },
+        __wbg_fromCharCode_7f1534c9ecd63754: function(arg0) {
+            const ret = String.fromCharCode(arg0 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_from_296ca31f8d0f1c52: function(arg0) {
+            const ret = Array.from(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_getAttribute_061ad00c16e2f622: function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg1).getAttribute(getStringFromWasm0(arg2, arg3));
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_getBoundingClientRect_57152b1a20f3de34: function(arg0) {
+            const ret = getObject(arg0).getBoundingClientRect();
+            return addHeapObject(ret);
+        },
+        __wbg_getComputedStyle_dd0f456804795fd6: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).getComputedStyle(getObject(arg1));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getContext_051324720aa5b7e8: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2), getObject(arg3));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getContext_189ce278aa985704: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2), getObject(arg3));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getContext_635e36719cad2623: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getContext_e567868594d2e0c6: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).getContext(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getData_bc58070c107b7d8a: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg1).getData(getStringFromWasm0(arg2, arg3));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_getElementById_cc94972b404e4eaa: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).getElementById(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_getExtension_abfda2c5db286b07: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).getExtension(getStringFromWasm0(arg1, arg2));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_getImageData_a8175cf7f34afc20: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).getImageData(arg1, arg2, arg3, arg4);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_getModifierState_506d6a27dcf99b93: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).getModifierState(getStringFromWasm0(arg1, arg2));
+            return ret;
+        },
+        __wbg_getModifierState_a793fec0ea3439f4: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).getModifierState(getStringFromWasm0(arg1, arg2));
+            return ret;
+        },
+        __wbg_getParameter_974595a6624c6c10: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).getParameter(arg1 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_getProgramInfoLog_3276b294d6d42fe2: function(arg0, arg1, arg2) {
+            const ret = getObject(arg1).getProgramInfoLog(getObject(arg2));
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_getProgramParameter_fc7124bb9fb7c675: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).getProgramParameter(getObject(arg1), arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_getPropertyValue_e90a3628c2de4fb6: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg1).getPropertyValue(getStringFromWasm0(arg2, arg3));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_getShaderInfoLog_7e0cbba353ca95da: function(arg0, arg1, arg2) {
+            const ret = getObject(arg1).getShaderInfoLog(getObject(arg2));
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_getShaderParameter_745acf10b8e45e31: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).getShaderParameter(getObject(arg1), arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_getUniformLocation_50ba45dade572703: function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).getUniformLocation(getObject(arg1), getStringFromWasm0(arg2, arg3));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_get_31af05bd4842a84f: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.get(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_get_6c896e0571ddae51: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_get_index_c2a95797340d0c18: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_index_c78b0af767cc90df: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return ret;
+        },
+        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
+            const ret = getObject(arg0)[arg1 >>> 0];
+            return addHeapObject(ret);
+        },
+        __wbg_has_5d6706e5209576c1: function() { return handleError(function (arg0, arg1) {
+            const ret = Reflect.has(getObject(arg0), getObject(arg1));
+            return ret;
+        }, arguments); },
+        __wbg_head_37fa26d1df5b82da: function(arg0) {
+            const ret = getObject(arg0).head;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_height_aa756cf29b6d629c: function(arg0) {
+            const ret = getObject(arg0).height;
+            return ret;
+        },
+        __wbg_height_fb13ed9fe991b5f4: function(arg0) {
+            const ret = getObject(arg0).height;
+            return ret;
+        },
+        __wbg_height_fc97e1a0c2e7331f: function(arg0) {
+            const ret = getObject(arg0).height;
+            return ret;
+        },
+        __wbg_historyLength_e3c5972aa7ea8386: function(arg0) {
+            const ret = getObject(arg0).historyLength;
+            return ret;
+        },
+        __wbg_host_bf79b73236067054: function(arg0, arg1) {
+            const ret = getObject(arg1).host;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_indexOf_c52c1d43e70cff1c: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).indexOf(getObject(arg1), arg2);
+            return ret;
+        },
+        __wbg_inputType_bcd41e55691a33d9: function(arg0, arg1) {
+            const ret = getObject(arg1).inputType;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_insertAdjacentElement_8e8afac9e989af7e: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).insertAdjacentElement(getStringFromWasm0(arg1, arg2), getObject(arg3));
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_insertBefore_f1ba67809033f6b1: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).insertBefore(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_instanceof_CanvasRenderingContext2d_769208c72dcbf5e6: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof CanvasRenderingContext2D;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_ClipboardEvent_cbfd05ef84dbba4f: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof ClipboardEvent;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Element_818e11074cdb63b5: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Element;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_FocusEvent_166336e0bd67dfa2: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof FocusEvent;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_HtmlCanvasElement_0a30c11fbbf41841: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof HTMLCanvasElement;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_HtmlElement_32fb153a5a0e2349: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof HTMLElement;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_ImageBitmap_74bea45ee48d3d7a: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof ImageBitmap;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_InputEvent_020398d31a393488: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof InputEvent;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_IntersectionObserverEntry_4fc8603ad90fd7c1: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof IntersectionObserverEntry;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_KeyboardEvent_0176f04c0ee63f6d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof KeyboardEvent;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Map_b2611749102d7ba3: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_MouseEvent_ce70f2c3ec0e40af: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof MouseEvent;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Node_177cfa58c50e2609: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Node;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Object_67a83cdc00c5d141: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Object;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_OffscreenCanvasRenderingContext2d_957f1a991324c9dc: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof OffscreenCanvasRenderingContext2D;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_PointerEvent_7da84319295c0048: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof PointerEvent;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Promise_e1dc6893aa1ece28: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Promise;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_RegExp_bf2189ffd9469e7d: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof RegExp;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint32Array_53a4facaf04b8a8b: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint32Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Uint8Array;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_WebGl2RenderingContext_64c994c14c0790fb: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof WebGL2RenderingContext;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_WheelEvent_614405cd78c84e54: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof WheelEvent;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_instanceof_Window_82d71df4eddf88bc: function(arg0) {
+            let result;
+            try {
+                result = getObject(arg0) instanceof Window;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
+        __wbg_intersectionRatio_9b8b39227a431a43: function(arg0) {
+            const ret = getObject(arg0).intersectionRatio;
+            return ret;
+        },
+        __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
+            const ret = Array.isArray(getObject(arg0));
+            return ret;
+        },
+        __wbg_isComposing_600c9236938f8e5a: function(arg0) {
+            const ret = getObject(arg0).isComposing;
+            return ret;
+        },
+        __wbg_isContextLost_fbbab8b921e614b7: function(arg0) {
+            const ret = getObject(arg0).isContextLost();
+            return ret;
+        },
+        __wbg_isTrusted_5038e49f9e965968: function(arg0) {
+            const ret = getObject(arg0).isTrusted;
+            return ret;
+        },
+        __wbg_is_4b278c0bd3caba97: function(arg0, arg1) {
+            const ret = Object.is(getObject(arg0), getObject(arg1));
+            return ret;
+        },
+        __wbg_keyCode_fbee6c8fd374ff5e: function(arg0) {
+            const ret = getObject(arg0).keyCode;
+            return ret;
+        },
+        __wbg_key_1193871533b99ae5: function(arg0, arg1) {
+            const ret = getObject(arg1).key;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_kittyFlags_6da9b73296a53cfb: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).kittyFlags();
+            return ret;
+        }, arguments); },
+        __wbg_lastIndexOf_6d1d667f9c5b714d: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).lastIndexOf(getObject(arg1), arg2);
+            return ret;
+        },
+        __wbg_last_index_90155c1f0b904b50: function(arg0) {
+            const ret = getObject(arg0).lastIndex;
+            return ret;
+        },
+        __wbg_last_index_9f2f3b788b926c76: function(arg0) {
+            const ret = getObject(arg0).lastIndex;
+            return ret;
+        },
+        __wbg_left_e0a244490fe2f293: function(arg0) {
+            const ret = getObject(arg0).left;
+            return ret;
+        },
+        __wbg_length_0acba72356589f9c: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_511b1f84719d3462: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_78dac82682e59660: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_7f3c00c40364105e: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_length_d4bdea10311bd9cf: function(arg0) {
+            const ret = getObject(arg0).length;
+            return ret;
+        },
+        __wbg_lineTo_63fac7d60279d95e: function(arg0, arg1, arg2) {
+            getObject(arg0).lineTo(arg1, arg2);
+        },
+        __wbg_lineWidth_385055522bc4230d: function(arg0) {
+            const ret = getObject(arg0).lineWidth;
+            return ret;
+        },
+        __wbg_linkProgram_acdc299c43d734a0: function(arg0, arg1) {
+            getObject(arg0).linkProgram(getObject(arg1));
+        },
+        __wbg_location_c84627eceac83abd: function(arg0) {
+            const ret = getObject(arg0).location;
+            return ret;
+        },
+        __wbg_loseContext_10540e383b0f5caa: function(arg0) {
+            getObject(arg0).loseContext();
+        },
+        __wbg_markerLine_3f1e0ec9226bafb3: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).markerLine(arg1 >>> 0);
+            return ret;
+        }, arguments); },
+        __wbg_marker_new: function(arg0) {
+            const ret = Marker.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_measureText_1035b288be51876c: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).measureText(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_measureText_57347b02ada3a4ad: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = getObject(arg0).measureText(getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_metaKey_9c3be2ab835b0148: function(arg0) {
+            const ret = getObject(arg0).metaKey;
+            return ret;
+        },
+        __wbg_metaKey_fb78da4d237d5bbb: function(arg0) {
+            const ret = getObject(arg0).metaKey;
+            return ret;
+        },
+        __wbg_modes_1153ca07297d4143: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).modes();
+            return ret;
+        }, arguments); },
+        __wbg_moveTo_037e3deefec91ae1: function(arg0, arg1, arg2) {
+            getObject(arg0).moveTo(arg1, arg2);
+        },
+        __wbg_navigator_2156486643462a87: function(arg0) {
+            const ret = getObject(arg0).navigator;
+            return addHeapObject(ret);
+        },
+        __wbg_new_1a8d2827bd9e1a2e: function() { return handleError(function (arg0) {
+            const ret = new ResizeObserver(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_1dbf7428bba60a42: function(arg0) {
+            const ret = new Uint8Array(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_28744009d011f847: function() {
+            const ret = new Map();
+            return addHeapObject(ret);
+        },
+        __wbg_new_2bdcdfcebdfc34d2: function(arg0, arg1) {
+            const ret = new TypeError(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_2f0c455872a7873c: function(arg0, arg1, arg2, arg3) {
+            const ret = new RegExp(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+            return addHeapObject(ret);
+        },
+        __wbg_new_343a093a3c2ffb4e: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_43256f3286588c85: function(arg0, arg1) {
+            const ret = new Proxy(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_617a8cdb8bb1130e: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_new_6ab88fbe741af6b5: function(arg0, arg1) {
+            const ret = new RangeError(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_74cd12440f4b8e4e: function(arg0) {
+            const ret = new Uint32Array(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_820eb53f620ccf82: function() { return handleError(function (arg0, arg1) {
+            const ret = new URL(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_a217df4351db4b9b: function() { return handleError(function (arg0, arg1) {
+            const ret = new OffscreenCanvas(arg0 >>> 0, arg1 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_a75d812182e1ebdf: function() { return handleError(function () {
+            const ret = new Path2D();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_cdbe4ae8dd393ba9: function(arg0) {
+            const ret = new WeakRef(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_new_d7061956449afe74: function() { return handleError(function (arg0) {
+            const ret = new Terminal2(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_ee2291f50781bf1d: function() {
+            const ret = new Array();
+            return addHeapObject(ret);
+        },
+        __wbg_new_ee8cb715333f443d: function() { return handleError(function (arg0) {
+            const ret = new IntersectionObserver(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_from_slice_37a3c3a194266cb8: function(arg0, arg1) {
+            const ret = new Uint32Array(getArrayU32FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
+            const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_new_typed_b01cb72a8af741a3: function(arg0, arg1) {
+            try {
+                var state0 = {a: arg0, b: arg1};
+                var cb0 = (arg0, arg1) => {
+                    const a = state0.a;
+                    state0.a = 0;
+                    try {
+                        return __wasm_bindgen_func_elem_2817(a, state0.b, arg0, arg1);
+                    } finally {
+                        state0.a = a;
+                    }
+                };
+                const ret = new Promise(cb0);
+                return addHeapObject(ret);
+            } finally {
+                state0.a = 0;
+            }
+        },
+        __wbg_new_with_length_31d0d732d07f3195: function(arg0) {
+            const ret = new Uint32Array(arg0 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_new_with_length_3da0ad195f6f63ba: function(arg0) {
+            const ret = new Uint8Array(arg0 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_new_with_u8_array_sequence_and_options_fccc08fe93f4b8fd: function() { return handleError(function (arg0, arg1) {
+            const ret = new Blob(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_new_with_u8_clamped_array_and_sh_af3f0dee40638e18: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = new ImageData(getClampedArrayU8FromWasm0(arg0, arg1), arg2 >>> 0, arg3 >>> 0);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_nextSibling_e5ecc9bf11c2365d: function(arg0) {
+            const ret = getObject(arg0).nextSibling;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_now_5641d929e64c440e: function() {
+            const ret = performance.now();
+            return ret;
+        },
+        __wbg_observe_d2ab4bf2d4e8bf9b: function(arg0, arg1) {
+            getObject(arg0).observe(getObject(arg1));
+        },
+        __wbg_observe_fa02ec4710cff1db: function(arg0, arg1) {
+            getObject(arg0).observe(getObject(arg1));
+        },
+        __wbg_of_20798cb14708764f: function(arg0, arg1) {
+            const ret = Array.of(getObject(arg0), getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_of_d5dbecdc59e02e34: function(arg0) {
+            const ret = Array.of(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_of_dde0b9d3265685ee: function(arg0, arg1, arg2) {
+            const ret = Array.of(getObject(arg0), getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_offsetHeight_427aaf53442f1586: function(arg0) {
+            const ret = getObject(arg0).offsetHeight;
+            return ret;
+        },
+        __wbg_offsetWidth_1d736667aa04ab3a: function(arg0) {
+            const ret = getObject(arg0).offsetWidth;
+            return ret;
+        },
+        __wbg_offsetY_bd621e751c6da59b: function(arg0) {
+            const ret = getObject(arg0).offsetY;
+            return ret;
+        },
+        __wbg_open_3ab3549fb9981fce: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).open();
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_ownerDocument_32ced9dbf52cf8d2: function(arg0) {
+            const ret = getObject(arg0).ownerDocument;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_pageY_11ed718f71a7d407: function(arg0) {
+            const ret = getObject(arg0).pageY;
+            return ret;
+        },
+        __wbg_parentElement_108b58de82cab63f: function(arg0) {
+            const ret = getObject(arg0).parentElement;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_parentNode_32afd0d7ad7dca98: function(arg0) {
+            const ret = getObject(arg0).parentNode;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_parseInt_9756a56948abd94c: function(arg0, arg1, arg2) {
+            const ret = parseInt(getStringFromWasm0(arg0, arg1), arg2);
+            return ret;
+        },
+        __wbg_parser_new: function(arg0) {
+            const ret = Parser.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_password_46dd1fd470b9b489: function(arg0, arg1) {
+            const ret = getObject(arg1).password;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_pen_f65b67fbddd27240: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).pen();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_pendingHook_91423ec32bdd88cf: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).pendingHook();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_placeImage_28f547d171a64292: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).placeImage(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, getObject(arg4));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_pointerId_1b91f6b6c8f92501: function(arg0) {
+            const ret = getObject(arg0).pointerId;
+            return ret;
+        },
+        __wbg_preventDefault_af59afb0f0a02e20: function(arg0) {
+            getObject(arg0).preventDefault();
+        },
+        __wbg_protocol_31c333d9fb09b193: function(arg0, arg1) {
+            const ret = getObject(arg1).protocol;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_prototypesetcall_06eb15da165dee8f: function(arg0, arg1, arg2) {
+            Uint32Array.prototype.set.call(getArrayU32FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __wbg_prototypesetcall_13adbfb002dee200: function(arg0, arg1, arg2) {
+            Int32Array.prototype.set.call(getArrayI32FromWasm0(arg0, arg1), getObject(arg2));
+        },
+        __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); },
+        __wbg_putImageData_cf1aa91e00a51b59: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+            getObject(arg0).putImageData(getObject(arg1), arg2, arg3, arg4, arg5, arg6, arg7);
+        }, arguments); },
+        __wbg_queueMicrotask_9833f9a49df95a49: function(arg0) {
+            const ret = getObject(arg0).queueMicrotask;
+            return addHeapObject(ret);
+        },
+        __wbg_queueMicrotask_a72f977e97f23c5f: function(arg0) {
+            queueMicrotask(getObject(arg0));
+        },
+        __wbg_rect_001744d79a46e02c: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).rect(arg1, arg2, arg3, arg4);
+        },
+        __wbg_reject_1548d2ad77237dc9: function(arg0) {
+            const ret = Promise.reject(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_relatedTarget_a8a7e56af040cacc: function(arg0) {
+            const ret = getObject(arg0).relatedTarget;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_releasePointerCapture_46ff9901159af8ef: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).releasePointerCapture(arg1);
+        }, arguments); },
+        __wbg_removeEventListener_261678bfcbd90907: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3), arg4 !== 0);
+        }, arguments); },
+        __wbg_removeEventListener_6e68185345978771: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            getObject(arg0).removeEventListener(getStringFromWasm0(arg1, arg2), getObject(arg3));
+        }, arguments); },
+        __wbg_removeMarker_0d2886f76d4a00e8: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).removeMarker(arg1 >>> 0);
+        }, arguments); },
+        __wbg_remove_1013622eead8b586: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).remove(getStringFromWasm0(arg1, arg2));
+        }, arguments); },
+        __wbg_remove_9a5288388316028c: function(arg0) {
+            getObject(arg0).remove();
+        },
+        __wbg_repeat_8e70ccf8a9875d04: function(arg0) {
+            const ret = getObject(arg0).repeat;
+            return ret;
+        },
+        __wbg_replaceWith_44b171f026e3cbce: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).replaceWith(getObject(arg1));
+        }, arguments); },
+        __wbg_replace_676e3cadfea1ea15: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).replace(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+            return addHeapObject(ret);
+        },
+        __wbg_replyClipboard_a583cb4f5fa586f8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg0).replyClipboard(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+            return ret;
+        }, arguments); },
+        __wbg_requestAnimationFrame_7dbeb9a79439da5d: function() { return handleError(function (arg0) {
+            const ret = requestAnimationFrame(getObject(arg0));
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_resetKittyKeyboard_202969274daebbf3: function() { return handleError(function (arg0) {
+            getObject(arg0).resetKittyKeyboard();
+        }, arguments); },
+        __wbg_resize_54f850aaf82593a0: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).resize(arg1 >>> 0, arg2 >>> 0);
+        }, arguments); },
+        __wbg_resolve_0076e10020304ede: function(arg0) {
+            const ret = Promise.resolve(getObject(arg0));
+            return addHeapObject(ret);
+        },
+        __wbg_restore_c93ba7571816b182: function(arg0) {
+            getObject(arg0).restore();
+        },
+        __wbg_resume_9c2e57af75412395: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).resume();
+            return ret;
+        }, arguments); },
+        __wbg_rowCellsView_ae8ee2f0774fe00c: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).rowCellsView(arg1);
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_rowExtras_df7303f96b00519e: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).rowExtras(arg1);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_rowImages_d6719a5d2533331e: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).rowImages(arg1);
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_rowWrapped_5c9f6ffff4960a54: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).rowWrapped(arg1);
+            return ret;
+        }, arguments); },
+        __wbg_rows_b3eee887a19dd0d8: function(arg0) {
+            const ret = getObject(arg0).rows;
+            return ret;
+        },
+        __wbg_save_f32554f1747071d1: function(arg0) {
+            getObject(arg0).save();
+        },
+        __wbg_scissor_12ddc324094acd50: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).scissor(arg1, arg2, arg3, arg4);
+        },
+        __wbg_scrollDisplay_86414e46dc46874b: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).scrollDisplay(arg1);
+        }, arguments); },
+        __wbg_scrollToBottom_b5e14cdb75fc408f: function() { return handleError(function (arg0) {
+            getObject(arg0).scrollToBottom();
+        }, arguments); },
+        __wbg_searchLine_5fed4b786679e43f: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).searchLine(arg1);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_searchRowsView_8fb325f88f629cb7: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+            const ret = getObject(arg0).searchRowsView(getObject(arg1), getObject(arg2), arg3, arg4, arg5 >>> 0);
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        }, arguments); },
+        __wbg_select_fe4329ce446004d9: function(arg0) {
+            getObject(arg0).select();
+        },
+        __wbg_selectionEnd_3b896630ecc8819e: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).selectionEnd;
+            return isLikeNone(ret) ? Number.MAX_SAFE_INTEGER : (ret) >>> 0;
+        }, arguments); },
+        __wbg_selectionStart_d78f4de323298a24: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).selectionStart;
+            return isLikeNone(ret) ? Number.MAX_SAFE_INTEGER : (ret) >>> 0;
+        }, arguments); },
+        __wbg_setAttribute_9e7d603908f63705: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).setAttribute(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_setClipboardAccess_4c94ad85027bd486: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).setClipboardAccess(getObject(arg1));
+        }, arguments); },
+        __wbg_setColors_22ff6fc3d14dc2b9: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).setColors(getObject(arg1));
+        }, arguments); },
+        __wbg_setCursorDefault_b6ccdfe69bb7cff0: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).setCursorDefault(getObject(arg1), arg2 !== 0);
+        }, arguments); },
+        __wbg_setData_5d08810e80ca40e2: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).setData(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_setFocus_a6999e957ef468c8: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).setFocus(arg1 !== 0);
+        }, arguments); },
+        __wbg_setHook_1f6e2be5d6c55f81: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).setHook(getStringFromWasm0(arg1, arg2), arg3 >>> 0, arg4 !== 0);
+        }, arguments); },
+        __wbg_setKittyKeyboard_bb5919bd3c269d11: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).setKittyKeyboard(arg1 !== 0);
+        }, arguments); },
+        __wbg_setLineDash_9fc0f9169c542b64: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).setLineDash(getObject(arg1));
+        }, arguments); },
+        __wbg_setPointerCapture_a53e23b7bccef290: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).setPointerCapture(arg1);
+        }, arguments); },
+        __wbg_setProperty_097bc3d55ce44513: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).setProperty(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_setTimeout_605b90fe456aa03a: function(arg0, arg1) {
+            const ret = setTimeout(getObject(arg0), arg1);
+            return addHeapObject(ret);
+        },
+        __wbg_setWindowsPty_6a7696fe8a55f359: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).setWindowsPty(getObject(arg1));
+        }, arguments); },
+        __wbg_set_145a351398b48c65: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
+        __wbg_set_6ae97e73113c4f0b: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).set(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_set_8c951ac96c7906f7: function(arg0, arg1, arg2) {
+            getObject(arg0).set(getObject(arg1), arg2 >>> 0);
+        },
+        __wbg_set_antialias_1f699e96763e8a35: function(arg0, arg1) {
+            getObject(arg0).antialias = arg1 !== 0;
+        },
+        __wbg_set_capture_5beff5b8a7562085: function(arg0, arg1) {
+            getObject(arg0).capture = arg1 !== 0;
+        },
+        __wbg_set_className_541fce5cd31918aa: function(arg0, arg1, arg2) {
+            getObject(arg0).className = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_depth_8b49de49803d4e60: function(arg0, arg1) {
+            getObject(arg0).depth = arg1 !== 0;
+        },
+        __wbg_set_dir_59e9eaab43c851a4: function(arg0, arg1, arg2) {
+            getObject(arg0).dir = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_fillStyle_00dcacffc57cf944: function(arg0, arg1) {
+            getObject(arg0).fillStyle = getObject(arg1);
+        },
+        __wbg_set_fillStyle_1a796925e818ac7c: function(arg0, arg1) {
+            getObject(arg0).fillStyle = getObject(arg1);
+        },
+        __wbg_set_fillStyle_a2961b4d44e572af: function(arg0, arg1, arg2) {
+            getObject(arg0).fillStyle = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_font_1f60a05a2544a2ff: function(arg0, arg1, arg2) {
+            getObject(arg0).font = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_font_7ef69121e02464cd: function(arg0, arg1, arg2) {
+            getObject(arg0).font = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_globalCompositeOperation_8d071d7528280f24: function() { return handleError(function (arg0, arg1, arg2) {
+            getObject(arg0).globalCompositeOperation = getStringFromWasm0(arg1, arg2);
+        }, arguments); },
+        __wbg_set_height_c9789c1c77eaedff: function(arg0, arg1) {
+            getObject(arg0).height = arg1 >>> 0;
+        },
+        __wbg_set_height_fde391767df1ce27: function(arg0, arg1) {
+            getObject(arg0).height = arg1 >>> 0;
+        },
+        __wbg_set_id_60955e6018d03b26: function(arg0, arg1, arg2) {
+            getObject(arg0).id = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_last_index_7f1ae2e7650c2bea: function(arg0, arg1) {
+            getObject(arg0).lastIndex = arg1 >>> 0;
+        },
+        __wbg_set_last_index_f0573e3d326c0224: function(arg0, arg1) {
+            getObject(arg0).lastIndex = arg1 >>> 0;
+        },
+        __wbg_set_lineWidth_cc15473552c60c9c: function(arg0, arg1) {
+            getObject(arg0).lineWidth = arg1;
+        },
+        __wbg_set_passive_31e9f895d2ac0046: function(arg0, arg1) {
+            getObject(arg0).passive = arg1 !== 0;
+        },
+        __wbg_set_preserve_drawing_buffer_e24a9888a6cb18b6: function(arg0, arg1) {
+            getObject(arg0).preserveDrawingBuffer = arg1 !== 0;
+        },
+        __wbg_set_prevent_scroll_aaa386836725b8b4: function(arg0, arg1) {
+            getObject(arg0).preventScroll = arg1 !== 0;
+        },
+        __wbg_set_readOnly_557b19cb2cdba070: function(arg0, arg1) {
+            getObject(arg0).readOnly = arg1 !== 0;
+        },
+        __wbg_set_resize_height_274433c2f249624d: function(arg0, arg1) {
+            getObject(arg0).resizeHeight = arg1 >>> 0;
+        },
+        __wbg_set_resize_width_6f06543b29d1ca48: function(arg0, arg1) {
+            getObject(arg0).resizeWidth = arg1 >>> 0;
+        },
+        __wbg_set_strokeStyle_d51608fa918b53d4: function(arg0, arg1, arg2) {
+            getObject(arg0).strokeStyle = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_tabIndex_6999832ea5d5197e: function(arg0, arg1) {
+            getObject(arg0).tabIndex = arg1;
+        },
+        __wbg_set_textBaseline_d5ba548751584f49: function(arg0, arg1, arg2) {
+            getObject(arg0).textBaseline = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_textContent_6d6fc559f198055f: function(arg0, arg1, arg2) {
+            getObject(arg0).textContent = arg1 === 0 ? undefined : getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_type_dcf75b2afa60c694: function(arg0, arg1, arg2) {
+            getObject(arg0).type = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_value_f5c1ffc19bac3037: function(arg0, arg1, arg2) {
+            getObject(arg0).value = getStringFromWasm0(arg1, arg2);
+        },
+        __wbg_set_width_0ca908d167690992: function(arg0, arg1) {
+            getObject(arg0).width = arg1 >>> 0;
+        },
+        __wbg_set_width_b0e1267db4b196b5: function(arg0, arg1) {
+            getObject(arg0).width = arg1 >>> 0;
+        },
+        __wbg_shaderSource_c8812639b47d87b9: function(arg0, arg1, arg2, arg3) {
+            getObject(arg0).shaderSource(getObject(arg1), getStringFromWasm0(arg2, arg3));
+        },
+        __wbg_shiftKey_be6d5295ee392b33: function(arg0) {
+            const ret = getObject(arg0).shiftKey;
+            return ret;
+        },
+        __wbg_shiftKey_ecdc496db72e8a50: function(arg0) {
+            const ret = getObject(arg0).shiftKey;
+            return ret;
+        },
+        __wbg_shift_e6e6ca1ae6dbe0ac: function(arg0) {
+            const ret = getObject(arg0).shift();
+            return addHeapObject(ret);
+        },
+        __wbg_slice_0aed45fc653b0ae8: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).slice(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_slice_3b71d4886a340363: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).slice(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_source_271a052f525a149a: function(arg0) {
+            const ret = getObject(arg0).source;
+            return addHeapObject(ret);
+        },
+        __wbg_startsWith_2b1a831cabe03881: function(arg0, arg1, arg2, arg3) {
+            const ret = getObject(arg0).startsWith(getStringFromWasm0(arg1, arg2), arg3 >>> 0);
+            return ret;
+        },
+        __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
+            const ret = typeof global === 'undefined' ? null : global;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
+            const ret = typeof globalThis === 'undefined' ? null : globalThis;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_SELF_0b583911f537483a: function() {
+            const ret = typeof self === 'undefined' ? null : self;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
+            const ret = typeof window === 'undefined' ? null : window;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_stopImmediatePropagation_9bcedd4bbc1fd172: function(arg0) {
+            getObject(arg0).stopImmediatePropagation();
+        },
+        __wbg_stopPropagation_effafbc3bc773f1c: function(arg0) {
+            getObject(arg0).stopPropagation();
+        },
+        __wbg_strokeText_acf127bdbf1ec111: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).strokeText(getStringFromWasm0(arg1, arg2), arg3, arg4);
+        }, arguments); },
+        __wbg_stroke_385d731098398489: function(arg0) {
+            getObject(arg0).stroke();
+        },
+        __wbg_style_4bce24230e493a7c: function(arg0) {
+            const ret = getObject(arg0).style;
+            return addHeapObject(ret);
+        },
+        __wbg_subarray_002b94d5e13d1411: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_subarray_bb23bc0b23af26d9: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_substring_7a68fc10027938a4: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).substring(arg1 >>> 0, arg2 >>> 0);
+            return addHeapObject(ret);
+        },
+        __wbg_syncPending_6e49d187941b7782: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).syncPending();
+            return ret;
+        }, arguments); },
+        __wbg_takeBells_d65728d8e1e2e9da: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).takeBells();
+            return ret;
+        }, arguments); },
+        __wbg_takeClipboardRead_5c8d80ed90f9a2e9: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg1).takeClipboardRead();
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_takeClipboardWrite_9282e2071d13ec95: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).takeClipboardWrite();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_takeDamage_041c075e09b3720d: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).takeDamage();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_takeDisposedMarkers_56cd79bbea4a0e9c: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).takeDisposedMarkers();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_takeReplyList_4c420c8f5487d9f4: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).takeReplyList();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_takeResets_cc11838347481a14: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).takeResets();
+            return ret;
+        }, arguments); },
+        __wbg_takeTitle_4153d9a66ce93c87: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg1).takeTitle();
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_target_38ae9feb025b820c: function(arg0) {
+            const ret = getObject(arg0).target;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_target_7c900590549b7e75: function(arg0) {
+            const ret = getObject(arg0).target;
+            return addHeapObject(ret);
+        },
+        __wbg_terminal_new: function(arg0) {
+            const ret = Terminal.__wrap(arg0);
+            return addHeapObject(ret);
+        },
+        __wbg_texImage2D_1b3349107ad0faae: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            getObject(arg0).texImage2D(arg1 >>> 0, arg2, arg3, arg4 >>> 0, arg5 >>> 0, getObject(arg6));
+        }, arguments); },
+        __wbg_texImage2D_ad7973ba95a99499: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            getObject(arg0).texImage2D(arg1 >>> 0, arg2, arg3, arg4 >>> 0, arg5 >>> 0, getObject(arg6));
+        }, arguments); },
+        __wbg_texImage2D_ca3d0fe24620ec85: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
+            getObject(arg0).texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, getObject(arg9));
+        }, arguments); },
+        __wbg_texParameteri_7864076abcdb03e0: function(arg0, arg1, arg2, arg3) {
+            getObject(arg0).texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
+        },
+        __wbg_texSubImage2D_cff3b090fb77dfe6: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
+            getObject(arg0).texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9 === 0 ? undefined : getArrayU8FromWasm0(arg9, arg10));
+        }, arguments); },
+        __wbg_textContent_acd42c63564a445e: function(arg0, arg1) {
+            const ret = getObject(arg1).textContent;
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_textRows_dc20af19957adbbd: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            const ret = getObject(arg1).textRows(arg2, arg3, arg4 !== 0);
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_then_c949d5a25a4e78f8: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_then_e71170d78fcf8954: function(arg0, arg1) {
+            const ret = getObject(arg0).then(getObject(arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_timeStamp_0bda9df1d6d64e7e: function(arg0) {
+            const ret = getObject(arg0).timeStamp;
+            return ret;
+        },
+        __wbg_toLocaleLowerCase_6cef75c259c10dbb: function(arg0, arg1, arg2) {
+            const ret = getObject(arg0).toLocaleLowerCase(arg1 === 0 ? undefined : getStringFromWasm0(arg1, arg2));
+            return addHeapObject(ret);
+        },
+        __wbg_toLowerCase_f66196e2ef2d8379: function(arg0) {
+            const ret = getObject(arg0).toLowerCase();
+            return addHeapObject(ret);
+        },
+        __wbg_toString_aad181a510c306d8: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).toString(arg1);
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_top_ff4627294d2cdeb8: function(arg0) {
+            const ret = getObject(arg0).top;
+            return ret;
+        },
+        __wbg_transferFromImageBitmap_475a297671a42832: function(arg0, arg1) {
+            getObject(arg0).transferFromImageBitmap(getObject(arg1));
+        },
+        __wbg_transferToImageBitmap_c2dae3e64c90a2a8: function() { return handleError(function (arg0) {
+            const ret = getObject(arg0).transferToImageBitmap();
+            return addHeapObject(ret);
+        }, arguments); },
+        __wbg_trimmedLines_2b7e5166a76b3147: function(arg0) {
+            const ret = getObject(arg0).trimmedLines;
+            return ret;
+        },
+        __wbg_type_b805b444107983c3: function(arg0, arg1) {
+            const ret = getObject(arg1).type;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_uniform1f_b5856e35a43b65a1: function(arg0, arg1, arg2) {
+            getObject(arg0).uniform1f(getObject(arg1), arg2);
+        },
+        __wbg_uniform1i_531b98c4a7177366: function(arg0, arg1, arg2) {
+            getObject(arg0).uniform1i(getObject(arg1), arg2);
+        },
+        __wbg_uniform1iv_4b8cbceccddfaa62: function(arg0, arg1, arg2, arg3) {
+            getObject(arg0).uniform1iv(getObject(arg1), getArrayI32FromWasm0(arg2, arg3));
+        },
+        __wbg_uniform2f_a92b5bb95dc5b4d9: function(arg0, arg1, arg2, arg3) {
+            getObject(arg0).uniform2f(getObject(arg1), arg2, arg3);
+        },
+        __wbg_uniformMatrix4fv_dff9738d995fd0b1: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).uniformMatrix4fv(getObject(arg1), arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
+        },
+        __wbg_unobserve_661058c2b30c2995: function(arg0, arg1) {
+            getObject(arg0).unobserve(getObject(arg1));
+        },
+        __wbg_unobserve_dacc4f2ae056f6c2: function(arg0, arg1) {
+            getObject(arg0).unobserve(getObject(arg1));
+        },
+        __wbg_useProgram_e075c2902e420761: function(arg0, arg1) {
+            getObject(arg0).useProgram(getObject(arg1));
+        },
+        __wbg_userAgent_cde4c65cc98db425: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg1).userAgent;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
+        __wbg_username_c27a22e0edb0b3c6: function(arg0, arg1) {
+            const ret = getObject(arg1).username;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbg_vertexAttribDivisor_7575d382215322f7: function(arg0, arg1, arg2) {
+            getObject(arg0).vertexAttribDivisor(arg1 >>> 0, arg2 >>> 0);
+        },
+        __wbg_vertexAttribPointer_24b495e18df325dc: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            getObject(arg0).vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
+        },
+        __wbg_view_d168f9b0b416ba51: function(arg0) {
+            const ret = getObject(arg0).view;
+            return isLikeNone(ret) ? 0 : addHeapObject(ret);
+        },
+        __wbg_viewport_16936692526e2ce6: function(arg0, arg1, arg2, arg3, arg4) {
+            getObject(arg0).viewport(arg1, arg2, arg3, arg4);
+        },
+        __wbg_warn_13abc63e0d4b3527: function(arg0) {
+            console.warn(getObject(arg0));
+        },
+        __wbg_warn_b083f6aa089f2e7c: function(arg0, arg1) {
+            console.warn(getObject(arg0), getObject(arg1));
+        },
+        __wbg_width_3d0dce3d9892e35e: function(arg0) {
+            const ret = getObject(arg0).width;
+            return ret;
+        },
+        __wbg_width_7a1b335e4a553dc3: function(arg0) {
+            const ret = getObject(arg0).width;
+            return ret;
+        },
+        __wbg_width_d5e379bde85b6eaa: function(arg0) {
+            const ret = getObject(arg0).width;
+            return ret;
+        },
+        __wbg_width_e95ad291d52fe17e: function(arg0) {
+            const ret = getObject(arg0).width;
+            return ret;
+        },
+        __wbg_writeUntilHook_fff6c84a04c8c53d: function() { return handleError(function (arg0, arg1) {
+            const ret = getObject(arg0).writeUntilHook(getObject(arg1));
+            return ret;
+        }, arguments); },
+        __wbg_write_27f2e67b4c683077: function() { return handleError(function (arg0, arg1) {
+            getObject(arg0).write(getObject(arg1));
+        }, arguments); },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref, Externref, Externref], shim_idx: 30, ret: Boolean, inner_ret: Some(Boolean) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_651);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000002: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref, Externref], shim_idx: 21, ret: Externref, inner_ret: Some(Externref) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_644);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000003: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref, Externref], shim_idx: 32, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_653);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000004: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_646);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000005: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 16, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_657);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000006: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 28, ret: Externref, inner_ret: Some(Externref) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_645);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000007: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 296, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_2801);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000008: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 34, ret: Externref, inner_ret: Some(Externref) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_655);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000009: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Array<any>")], shim_idx: 16, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_657_148);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_000000000000000a: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 1, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_646_149);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_000000000000000b: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 16, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_657_150);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_000000000000000c: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [U32, Externref], shim_idx: 21, ret: Externref, inner_ret: Some(Externref) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_644_151);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_000000000000000d: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [U32, U32, Externref], shim_idx: 23, ret: Externref, inner_ret: Some(Externref) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_647);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_000000000000000e: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [U32, U32, U32, Externref], shim_idx: 19, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_648);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_000000000000000f: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 26, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            const ret = makeClosure(arg0, arg1, __wasm_bindgen_func_elem_649);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000010: function(arg0, arg1) {
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_659);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000011: function(arg0) {
+            // Cast intrinsic for `F64 -> Externref`.
+            const ret = arg0;
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000012: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.
+            const ret = getArrayF32FromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000013: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(Slice(U32)) -> NamedExternref("Uint32Array")`.
+            const ret = getArrayU32FromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_generic_0000000000000014: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./xterm_web_bg.js": import0,
+    };
+}
+
+function __wasm_bindgen_func_elem_649(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_649(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_659(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_659(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_646(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_646(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_657(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_657(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_657_148(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_657_148(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_646_149(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_646_149(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_657_150(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_657_150(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_645(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_645(arg0, arg1, addHeapObject(arg2));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_655(arg0, arg1, arg2) {
+    const ret = wasm.__wasm_bindgen_func_elem_655(arg0, arg1, addHeapObject(arg2));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_2817(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_2817(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+function __wasm_bindgen_func_elem_2801(arg0, arg1, arg2) {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.__wasm_bindgen_func_elem_2801(retptr, arg0, arg1, addHeapObject(arg2));
+        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);
+    }
+}
+
+function __wasm_bindgen_func_elem_644(arg0, arg1, arg2, arg3) {
+    const ret = wasm.__wasm_bindgen_func_elem_644(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_653(arg0, arg1, arg2, arg3) {
+    const ret = wasm.__wasm_bindgen_func_elem_653(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_644_151(arg0, arg1, arg2, arg3) {
+    const ret = wasm.__wasm_bindgen_func_elem_644_151(arg0, arg1, arg2, addHeapObject(arg3));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_651(arg0, arg1, arg2, arg3, arg4) {
+    const ret = wasm.__wasm_bindgen_func_elem_651(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3), addHeapObject(arg4));
+    return ret !== 0;
+}
+
+function __wasm_bindgen_func_elem_647(arg0, arg1, arg2, arg3, arg4) {
+    const ret = wasm.__wasm_bindgen_func_elem_647(arg0, arg1, arg2, arg3, addHeapObject(arg4));
+    return takeObject(ret);
+}
+
+function __wasm_bindgen_func_elem_648(arg0, arg1, arg2, arg3, arg4, arg5) {
+    wasm.__wasm_bindgen_func_elem_648(arg0, arg1, arg2, arg3, arg4, addHeapObject(arg5));
+}
+
+const BufferCellFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_buffercell_free(ptr, 1));
+const BufferLineFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bufferline_free(ptr, 1));
+const BufferNamespaceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_buffernamespace_free(ptr, 1));
+const BufferViewFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bufferview_free(ptr, 1));
+const DisposableFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_disposable_free(ptr, 1));
+const FitAddonFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_fitaddon_free(ptr, 1));
+const ImageAddonFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_imageaddon_free(ptr, 1));
+const MarkerFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_marker_free(ptr, 1));
+const ParserFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_parser_free(ptr, 1));
+const SearchAddonFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_searchaddon_free(ptr, 1));
+const TerminalFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_terminal_free(ptr, 1));
+const UnicodeHandlingFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_unicodehandling_free(ptr, 1));
+const WebLinksAddonFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_weblinksaddon_free(ptr, 1));
+const WebglAddonFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_webgladdon_free(ptr, 1));
+
+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 _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => wasm.__wbindgen_export4(state.a, state.b));
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayI32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU16FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
+}
+
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    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)) {
+        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 cachedInt32ArrayMemory0 = null;
+function getInt32ArrayMemory0() {
+    if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
+        cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
+    }
+    return cachedInt32ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint16ArrayMemory0 = null;
+function getUint16ArrayMemory0() {
+    if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
+        cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
+    }
+    return cachedUint16ArrayMemory0;
+}
+
+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;
+}
+
+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) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        try {
+            return f(state.a, state.b, ...args);
+        } finally {
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_export4(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function makeMutClosure(arg0, arg1, f) {
+    const state = { a: arg0, b: arg1, cnt: 1 };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            wasm.__wbindgen_export4(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.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 takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+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;
+    cachedInt32ArrayMemory0 = null;
+    cachedUint16ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    cachedUint8ClampedArrayMemory0 = null;
+    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('xterm_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 };