wongtty 0.0.1 → 0.0.3

package/README.md

@@ -5,7 +5,7 @@ xterm.js 6.x `Terminal` API over that engine, with a WebGL2 renderer, also in
 Rust. Built to keep memory low with many terminals open: all panes on a page
 share one engine module, one WebGL2 context and one glyph atlas.
 
-**Status: 0.0.1, experimental.**
+**Status: 0.0.2, experimental.**
 
 ## Install
 

package/dist/index.d.ts

@@ -86,12 +86,16 @@ export interface Hook {
 
 /** How `searchNext` and friends compare text. */
 export interface SearchOptions {
-  /** Off: matched with the RegExp `i` flag. */
+  /**
+   * Off: matched with the RegExp `i` flag, but by `searchRows` of a plain ASCII query, which the engine matches
+   * with each line lowercased as the N-API binding does (U+212A KELVIN SIGN reads as `k`, U+0130 as `i` + U+0307).
+   */
   caseSensitive?: boolean;
   /** A match needs a non-word character (`@xterm/addon-search`'s set, so not `_`) or a line end on both sides. */
   wholeWord?: boolean;
-  /** `query` is a JavaScript regular expression (flag `g`); otherwise it is matched as plain text. Either way the
-   * matching runs in JS over each logical line's text (`searchLine`). */
+  /** `query` is a JavaScript regular expression (flag `g`); otherwise it is matched as plain text. Regular
+   * expressions, and plain queries but for `searchRows` of an ASCII one, are matched in JS over each logical line's
+   * text (`searchLine`). */
   regex?: boolean;
 }
 
@@ -141,6 +145,11 @@ export class Terminal {
    */
   readonly trimmedLines: number;
   rowText(line: number): string | null;
+  /**
+   * `translateToString(trimRight)` of lines `first`…`last` (clamped to the buffer; by default all of it), each
+   * followed by `\n`, in one call. `trimRight` defaults to true.
+   */
+  textRows(first?: number, last?: number, trimRight?: boolean): string;
   /** `[codepoint, fg, bg, attrs]` per cell. */
   rowCells(line: number): Uint32Array | null;
   /**
@@ -232,12 +241,27 @@ export class Terminal {
   /**
    * The first match of `query` starting at or after cell (`line`, `col`), down to the bottom of the screen (no
    * wrap-around). Defaults to the top of the history. Matches never span logical lines (rows joined by soft wraps).
+   * Ignoring case, it folds as the RegExp `i` flag does, not as `searchRows` of a plain ASCII query: a match on
+   * U+212A or U+0130 that `searchRows` finds is skipped here (`SearchOptions.caseSensitive`).
    */
   searchNext(query: string, options?: SearchOptions, line?: number, col?: number): SearchMatch | null;
   /** The last match ending at or before cell (`line`, `col`), up to the top of the history. Defaults to the end of the screen. */
   searchPrevious(query: string, options?: SearchOptions, line?: number, col?: number): SearchMatch | null;
   /** Every match in the logical lines rows `first`…`last` belong to (each search goes on from the end of the previous match), keeping those that touch the rows. */
   searchRows(query: string, options: SearchOptions | undefined, first: number, last: number): SearchMatch[];
+  /**
+   * The engine's matching of a plain `query` over rows `first`…`last` (`searchRows` without `regex`): at most
+   * `limit` matches as `[startLine, startCol, endLine, endCol]` each, a view into WebAssembly memory valid only until
+   * the next call into any terminal. Null for a query that is not ASCII and, with `keepLength`, when a line with a
+   * match holds U+0130 (İ), which lowercases to two characters (for hosts that lowercase whole lines themselves).
+   */
+  searchRowsView(
+    query: string,
+    options: { caseSensitive?: boolean; wholeWord?: boolean; keepLength?: boolean } | undefined,
+    first: number,
+    last: number,
+    limit?: number,
+  ): Int32Array | null;
   /** The logical line row `line` belongs to, as search reads it, for matching the text yourself; null outside the buffer. */
   searchLine(line: number): SearchLine | null;
   /**

package/dist/index.js

@@ -1,7 +1,7 @@
 // wongtty — terminal emulator engine (Rust → WebAssembly).
 // Works in browsers, bundlers (Vite/webpack resolve the .wasm URL) and Node ≥ 18.
 
-const ABI = 14;
+const ABI = 15;
 const encoder = new TextEncoder();
 const decoder = new TextDecoder();
 // Input buffer: smallest allocation, and the largest one kept between writes.
@@ -104,6 +104,11 @@ const bytesOut = (len) => new Uint8Array(wasm.memory.buffer, wasm.wongtty_out_pt
 const textOut = (len) => (len <= 0 ? '' : decoder.decode(new Uint8Array(wasm.memory.buffer, wasm.wongtty_out_ptr(), len)));
 const wordsOut = (n) => (n <= 0 ? new Uint32Array(0) : new Uint32Array(wasm.memory.buffer, wasm.wongtty_out32_ptr(), n).slice());
 
+/** Rows `textRows` asks the engine for at a time, so the text it holds in its memory stays small. */
+const TEXT_BLOCK = 1024;
+/** Matches `searchRows` asks the engine for at a time (16 bytes each in its memory), so a common query does not grow it. */
+const MATCH_PAGE = 4096;
+
 /** `@xterm/addon-search` `NON_WORD_CHARACTERS`: what ends a word for `wholeWord`. */
 const NON_WORD = ' ~!@#$%^&*()+`-=[]{}|\\;:"\',./<>?';
 const CELL_WIDE = 0x80000000;
@@ -426,6 +431,22 @@ export class Terminal {
     return n < 0 ? null : textOut(n);
   }
 
+  /**
+   * `translateToString(trimRight)` of lines `first`…`last` (clamped to the buffer), each followed by `\n`.
+   * @returns {string}
+   */
+  textRows(first = -this.historyLength, last = this.rows - 1, trimRight = true) {
+    const h = this.#handle();
+    first = Math.max(first, -this.historyLength);
+    last = Math.min(last, this.rows - 1);
+    let text = '';
+    for (let from = first; from <= last; from += TEXT_BLOCK) {
+      text += textOut(wasm.wongtty_text_rows(h, from, Math.min(from + TEXT_BLOCK - 1, last), trimRight ? 1 : 0));
+    }
+    wasm.wongtty_out_release();
+    return text;
+  }
+
   /** `[codepoint, fg, bg, attrs]` per cell. @returns {Uint32Array | null} */
   rowCells(line) {
     const n = wasm.wongtty_row_cells(this.#handle(), line);
@@ -648,7 +669,8 @@ export class Terminal {
   }
 
   // Search runs here over the engine's logical lines (`searchLine`), with a RegExp for every query: a plain one is
-  // escaped, and the `i` flag folds case without changing lengths. Matching in the wasm would cost the size budget.
+  // escaped, and the `i` flag folds case without changing lengths. Only `searchRows` of a plain ASCII query is
+  // matched in the engine (`searchRowsView`), whose ASCII case folding needs no Unicode tables in the wasm.
   #matcher(query, { caseSensitive = false, regex = false } = {}) {
     return new RegExp(regex ? query : query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), caseSensitive ? 'g' : 'gi');
   }
@@ -702,6 +724,18 @@ export class Terminal {
   searchRows(query, options = {}, first, last) {
     const out = [];
     if (!query) return out;
+    // Page by page, each from just after the last match
+    for (let line = -0x80000000, col = 0; !options.regex; ) {
+      const m = this.#searchRowsAt(query, options, first, last, MATCH_PAGE, line, col);
+      if (!m) break;
+      for (let i = 0; i < m.length; i += 4) out.push({ startLine: m[i], startCol: m[i + 1], endLine: m[i + 2], endCol: m[i + 3] });
+      if (m.length < MATCH_PAGE * 4) {
+        wasm.wongtty_out_release();
+        return out;
+      }
+      [line, col] = [m[m.length - 4], m[m.length - 3] + 1];
+    }
+    out.length = 0;
     const re = this.#matcher(query, options);
     last = Math.min(last, this.rows - 1);
     let found = this.searchLine(Math.max(first, -this.historyLength));
@@ -715,6 +749,39 @@ export class Terminal {
     return out;
   }
 
+  /**
+   * The engine's matching of a plain `query` over rows `first`…`last` (`searchRows` without `regex`): at most
+   * `limit` matches as `[startLine, startCol, endLine, endCol]` each, a view into WebAssembly memory valid only until
+   * the next call into any terminal. Null for a query that is not ASCII and, with `keepLength`, when a line with a
+   * match holds U+0130 (İ): ignoring case it lowercases to two characters, where a host that lowercases whole lines
+   * (`@xterm/addon-search`) places matches differently. @returns {Int32Array | null}
+   */
+  searchRowsView(query, options = {}, first, last, limit = 0xffffffff) {
+    return this.#searchRowsAt(query, options, first, last, limit, -0x80000000, 0);
+  }
+
+  // `searchRowsView` of the matches starting at or after cell (`line`, `col`).
+  #searchRowsAt(query, { caseSensitive = false, wholeWord = false, keepLength = false }, first, last, limit, line, col) {
+    const h = this.#handle();
+    // Bounds past the buffer (±Infinity too) are its ends, as the RegExp path reads them; NaN finds nothing
+    first = Math.max(first, -this.historyLength);
+    last = Math.min(last, this.rows - 1);
+    if (!(first <= last)) return new Int32Array(0);
+    const bytes = encoder.encode(query);
+    const ptr = this.#reserve(20 + bytes.length);
+    const head = new DataView(wasm.memory.buffer, ptr, 20);
+    head.setInt32(0, first, true);
+    head.setInt32(4, last, true);
+    head.setUint32(8, Math.min(limit, 0xffffffff), true);
+    head.setInt32(12, line, true);
+    head.setUint32(16, col, true);
+    new Uint8Array(wasm.memory.buffer, ptr + 20, bytes.length).set(bytes);
+    const flags = (caseSensitive ? 1 : 0) | (wholeWord ? 2 : 0) | (keepLength ? 4 : 0);
+    const n = wasm.wongtty_search_rows(h, ptr, 20 + bytes.length, flags);
+    this.#shrinkInput();
+    return n < 0 ? null : new Int32Array(wasm.memory.buffer, wasm.wongtty_out32_ptr(), n * 4);
+  }
+
   /**
    * The logical line row `line` belongs to as search reads it, or null outside the buffer. `cells[i]` is the cell of
    * the UTF-16 unit `text[i]`: `row * cols + col` from `first`, bit 31 set for a wide character.

package/dist/xterm_web.d.ts

@@ -895,23 +895,23 @@ export interface InitOutput {
     readonly weblinksaddon_activate: (a: number, b: number) => void;
     readonly weblinksaddon_dispose: (a: number) => void;
     readonly weblinksaddon_new: (a: number, b: number) => number;
-    readonly __wasm_bindgen_func_elem_644: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-    readonly __wasm_bindgen_func_elem_643: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly __wasm_bindgen_func_elem_648: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly __wasm_bindgen_func_elem_647: (a: number, b: number, c: number, d: number, e: number) => number;
-    readonly __wasm_bindgen_func_elem_640: (a: number, b: number, c: number, d: number) => number;
-    readonly __wasm_bindgen_func_elem_640_151: (a: number, b: number, c: number, d: number) => number;
-    readonly __wasm_bindgen_func_elem_649: (a: number, b: number, c: number, d: number) => number;
-    readonly __wasm_bindgen_func_elem_2791: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_2807: (a: number, b: number, c: number, d: number) => void;
-    readonly __wasm_bindgen_func_elem_641: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_651: (a: number, b: number, c: number) => number;
-    readonly __wasm_bindgen_func_elem_642: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_642_149: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_653: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_653_148: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_653_150: (a: number, b: number, c: number) => void;
-    readonly __wasm_bindgen_func_elem_645: (a: number, b: number) => void;
-    readonly __wasm_bindgen_func_elem_655: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_651: (a: number, b: number, c: number, d: number, e: number) => number;
+    readonly __wasm_bindgen_func_elem_644: (a: number, b: number, c: number, d: number) => number;
+    readonly __wasm_bindgen_func_elem_644_151: (a: number, b: number, c: number, d: number) => number;
+    readonly __wasm_bindgen_func_elem_653: (a: number, b: number, c: number, d: number) => number;
+    readonly __wasm_bindgen_func_elem_2801: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_2817: (a: number, b: number, c: number, d: number) => void;
+    readonly __wasm_bindgen_func_elem_645: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_655: (a: number, b: number, c: number) => number;
+    readonly __wasm_bindgen_func_elem_646: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_646_149: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_657: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_657_148: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_657_150: (a: number, b: number, c: number) => void;
+    readonly __wasm_bindgen_func_elem_649: (a: number, b: number) => void;
+    readonly __wasm_bindgen_func_elem_659: (a: number, b: number) => void;
     readonly __wbindgen_export: (a: number) => void;
     readonly __wbindgen_export2: (a: number, b: number) => number;
     readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;

package/dist/xterm_web.js

@@ -2601,6 +2601,10 @@ function __wbg_get_imports() {
             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;
@@ -2752,7 +2756,7 @@ function __wbg_get_imports() {
                     const a = state0.a;
                     state0.a = 0;
                     try {
-                        return __wasm_bindgen_func_elem_2807(a, state0.b, arg0, arg1);
+                        return __wasm_bindgen_func_elem_2817(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -2881,6 +2885,9 @@ function __wbg_get_imports() {
         __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));
         },
@@ -3002,6 +3009,10 @@ function __wbg_get_imports() {
             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();
         },
@@ -3308,6 +3319,13 @@ function __wbg_get_imports() {
             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);
@@ -3436,82 +3454,82 @@ function __wbg_get_imports() {
         }, 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_647);
+            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_640);
+            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_649);
+            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_642);
+            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_653);
+            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_641);
+            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_2791);
+            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_651);
+            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_653_148);
+            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_642_149);
+            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_653_150);
+            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_640_151);
+            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_643);
+            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_644);
+            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_645);
+            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_655);
+            const ret = makeMutClosure(arg0, arg1, __wasm_bindgen_func_elem_659);
             return addHeapObject(ret);
         },
         __wbindgen_generic_0000000000000011: function(arg0) {
@@ -3548,52 +3566,52 @@ function __wbg_get_imports() {
     };
 }
 
-function __wasm_bindgen_func_elem_645(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_645(arg0, arg1);
+function __wasm_bindgen_func_elem_649(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_649(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_655(arg0, arg1) {
-    wasm.__wasm_bindgen_func_elem_655(arg0, arg1);
+function __wasm_bindgen_func_elem_659(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_659(arg0, arg1);
 }
 
-function __wasm_bindgen_func_elem_642(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_642(arg0, arg1, addHeapObject(arg2));
+function __wasm_bindgen_func_elem_646(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_646(arg0, arg1, addHeapObject(arg2));
 }
 
-function __wasm_bindgen_func_elem_653(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_653(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_653_148(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_653_148(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_642_149(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_642_149(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_653_150(arg0, arg1, arg2) {
-    wasm.__wasm_bindgen_func_elem_653_150(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_641(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_641(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_651(arg0, arg1, arg2) {
-    const ret = wasm.__wasm_bindgen_func_elem_651(arg0, arg1, addHeapObject(arg2));
+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_2807(arg0, arg1, arg2, arg3) {
-    wasm.__wasm_bindgen_func_elem_2807(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+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_2791(arg0, arg1, arg2) {
+function __wasm_bindgen_func_elem_2801(arg0, arg1, arg2) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.__wasm_bindgen_func_elem_2791(retptr, arg0, arg1, addHeapObject(arg2));
+        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) {
@@ -3604,33 +3622,33 @@ function __wasm_bindgen_func_elem_2791(arg0, arg1, arg2) {
     }
 }
 
-function __wasm_bindgen_func_elem_640(arg0, arg1, arg2, arg3) {
-    const ret = wasm.__wasm_bindgen_func_elem_640(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+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_649(arg0, arg1, arg2, arg3) {
-    const ret = wasm.__wasm_bindgen_func_elem_649(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+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_640_151(arg0, arg1, arg2, arg3) {
-    const ret = wasm.__wasm_bindgen_func_elem_640_151(arg0, arg1, arg2, addHeapObject(arg3));
+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_647(arg0, arg1, arg2, arg3, arg4) {
-    const ret = wasm.__wasm_bindgen_func_elem_647(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3), addHeapObject(arg4));
+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_643(arg0, arg1, arg2, arg3, arg4) {
-    const ret = wasm.__wasm_bindgen_func_elem_643(arg0, arg1, arg2, arg3, addHeapObject(arg4));
+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_644(arg0, arg1, arg2, arg3, arg4, arg5) {
-    wasm.__wasm_bindgen_func_elem_644(arg0, arg1, arg2, arg3, arg4, addHeapObject(arg5));
+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')

package/dist/xterm_web_bg.wasm.d.ts

@@ -154,23 +154,23 @@ export const weblinksaddon___wongttyWebLinksAddon: (a: number) => number;
 export const weblinksaddon_activate: (a: number, b: number) => void;
 export const weblinksaddon_dispose: (a: number) => void;
 export const weblinksaddon_new: (a: number, b: number) => number;
-export const __wasm_bindgen_func_elem_644: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
-export const __wasm_bindgen_func_elem_643: (a: number, b: number, c: number, d: number, e: number) => number;
+export const __wasm_bindgen_func_elem_648: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
 export const __wasm_bindgen_func_elem_647: (a: number, b: number, c: number, d: number, e: number) => number;
-export const __wasm_bindgen_func_elem_640: (a: number, b: number, c: number, d: number) => number;
-export const __wasm_bindgen_func_elem_640_151: (a: number, b: number, c: number, d: number) => number;
-export const __wasm_bindgen_func_elem_649: (a: number, b: number, c: number, d: number) => number;
-export const __wasm_bindgen_func_elem_2791: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_2807: (a: number, b: number, c: number, d: number) => void;
-export const __wasm_bindgen_func_elem_641: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_651: (a: number, b: number, c: number) => number;
-export const __wasm_bindgen_func_elem_642: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_642_149: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_653: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_653_148: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_653_150: (a: number, b: number, c: number) => void;
-export const __wasm_bindgen_func_elem_645: (a: number, b: number) => void;
-export const __wasm_bindgen_func_elem_655: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_651: (a: number, b: number, c: number, d: number, e: number) => number;
+export const __wasm_bindgen_func_elem_644: (a: number, b: number, c: number, d: number) => number;
+export const __wasm_bindgen_func_elem_644_151: (a: number, b: number, c: number, d: number) => number;
+export const __wasm_bindgen_func_elem_653: (a: number, b: number, c: number, d: number) => number;
+export const __wasm_bindgen_func_elem_2801: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_2817: (a: number, b: number, c: number, d: number) => void;
+export const __wasm_bindgen_func_elem_645: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_655: (a: number, b: number, c: number) => number;
+export const __wasm_bindgen_func_elem_646: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_646_149: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_657: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_657_148: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_657_150: (a: number, b: number, c: number) => void;
+export const __wasm_bindgen_func_elem_649: (a: number, b: number) => void;
+export const __wasm_bindgen_func_elem_659: (a: number, b: number) => void;
 export const __wbindgen_export: (a: number) => void;
 export const __wbindgen_export2: (a: number, b: number) => number;
 export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wongtty",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Terminal emulator engine in Rust, compiled to WebAssembly. Feed it PTY bytes, render the rows that changed.",
   "type": "module",
   "main": "./dist/index.js",