rust-fetch 2.0.0 → 2.1.0

package/README.md

@@ -43,7 +43,7 @@ const { body: user } = await api.get('/users/42');
 - **Streaming** responses as a `ReadableStream`, and **download progress** callbacks.
 - **Interceptors** for requests and responses, e.g. auth headers and token refresh.
 - **TypeScript** definitions for the whole API.
-- **Tested**: 100% line coverage of the Rust core, plus wasm tests and end-to-end tests of the packed npm package. See [Development](#development).
+- **Tested**: 100% line coverage of the Rust core and of the Node.js transport, plus wasm tests and end-to-end tests of the packed npm package. See [Development](#development).
 
 ## Installation
 
@@ -105,7 +105,7 @@ await client.get('/search', { params: { q: 'rust wasm', page: 2, tag: ['a', 'b']
 await client.fetch('/users/1', { method: 'DELETE', headers: { 'X-Reason': 'cleanup' } });
 ```
 
-Relative URLs need a `baseUrl`. In a browser page without one, they resolve against the page URL. Absolute URLs always win over `baseUrl`. `TRACE` and `CONNECT` are rejected because `fetch()` forbids them.
+Relative URLs need a `baseUrl`. In a browser page without one, they resolve against the page URL. Absolute URLs always win over `baseUrl`. `TRACE` and `CONNECT` are rejected, because browsers' `fetch()` forbids them.
 
 #### Request options
 
@@ -223,7 +223,7 @@ controller.abort(); // rejects with a CancelledError
 await client.get('/report', { signal: AbortSignal.timeout(5_000) }); // total deadline, including retries
 ```
 
-Aborting cancels the underlying `fetch`, any pending retry delay, and a body being streamed.
+Aborting cancels the request in flight, any pending retry delay, and a body being streamed.
 
 ### Streaming
 
@@ -352,18 +352,20 @@ Request futures are `Send`, so you can `tokio::spawn` them. Progress callbacks (
 
 ## Performance
 
-rust-fetch makes its requests through the runtime's own `fetch()`, so the network work is the same as plain `fetch`. The extra cost comes from crossing the JS ↔ Wasm boundary and copying bodies. It is **not faster than native `fetch`**. Use it for the reliability features, not for speed.
+**In Node.js, rust-fetch is as fast as or faster than the built-in `fetch()` for typical API traffic.** Node's `fetch()` implements browser semantics (WHATWG streams) on top of its sockets. rust-fetch uses its own lean transport on `node:http`/`node:https` with keep-alive. Retries, timeouts, validation and errors still come from the Rust core.
 
-`npm run bench` (Node 22.13, Apple M1 Pro, local server):
+`npm run bench` (Node 22.13, Apple M1 Pro, local server, median of 5 alternating rounds):
 
 | Scenario | native `fetch` | rust-fetch | rust-fetch / native |
 | --- | ---: | ---: | ---: |
-| Small JSON, sequential | 5,465 req/s | 4,015 req/s | 73% |
-| Small JSON, 50 concurrent | 12,155 req/s | 6,035 req/s | 50% |
-| JSON 0.6 MB | 219 req/s | 212 req/s | 97% |
-| Binary 8 MB | 189 req/s | 147 req/s | 77% |
+| Small JSON, sequential | 10,558 req/s | 10,634 req/s | **101%** |
+| Small JSON, 50 concurrent | 13,401 req/s | 13,895 req/s | **104%** |
+| JSON 0.6 MB | 219 req/s | 203 req/s | 92% |
+| Binary 8 MB | 177 req/s | 181 req/s | **102%** |
 
-The overhead per request is a fraction of a millisecond, which matters little once a request crosses a real network.
+Large JSON is dominated by `JSON.parse`, which both clients pay; the remaining gap is extra garbage collection from crossing into Wasm.
+
+**In browsers**, `fetch()` is the only way to make requests, so rust-fetch uses it and can't be faster than it. The difference is a fraction of a millisecond per request, which matters little once a request crosses a real network.
 
 ## Roadmap
 
@@ -379,9 +381,9 @@ The overhead per request is a fraction of a millisecond, which matters little on
 - [ ] Upload progress tracking: not possible on top of `fetch()`, which has no upload progress events
 - [ ] WebSocket support
 - Handled by the runtime, not by rust-fetch:
-  - **Connection pooling:** browsers and Node.js pool connections for `fetch()` themselves.
-  - **Proxies:** set them up in the runtime, e.g. with undici's `setGlobalDispatcher(new ProxyAgent(url))` in Node.js, or with system settings in browsers.
-  - **HTTP/2:** browsers negotiate it automatically; in Node.js it depends on undici's dispatcher (`allowH2`).
+  - **Connection pooling:** browsers pool connections for `fetch()`; in Node.js rust-fetch reuses connections through Node's default keep-alive agents.
+  - **Proxies:** in Node.js, install a proxy agent as `http.globalAgent` / `https.globalAgent` (for example from `https-proxy-agent`). In browsers, use the system settings.
+  - **HTTP/2:** browsers negotiate it automatically; the Node.js transport uses HTTP/1.1 with keep-alive.
 
 ## Upgrading to 2.0
 
@@ -420,6 +422,7 @@ npm run test:js    # JS end-to-end tests against the built package (requires a b
 npm run bench      # rust-fetch vs native fetch (requires a build)
 npm run size       # size budget for the built package
 npm run api:check  # public TypeScript API vs the committed snapshot
+npm run coverage:js  # Node.js transport coverage (100% lines and functions)
 
 cd wasm-module
 wasm-pack test --node    # wasm unit tests for the JS bindings
@@ -434,7 +437,7 @@ cargo llvm-cov --ignore-filename-regex 'src/(wasm/|http\.rs)|tests/'   # coverag
 | JS end-to-end tests | `wasm-module/js/test/client.test.mjs` | The built package against a local server |
 | Package tests | `wasm-module/js/test/package.test.mjs` | Installs the packed tarball and uses it via `import`, `require`, the browser entry and its types |
 
-CI runs the Rust suites with a coverage gate that fails if line or function coverage of the Rust core drops below 100%. It also runs the wasm and JS suites on Node 20, 22 and 24, and checks formatting, dependencies (security advisories and licenses), API compatibility and the size budget. See [CONTRIBUTING.md](CONTRIBUTING.md#pull-requests). The JS-only bindings in `src/wasm/` and `src/http.rs` need a JS engine, so they're covered by the wasm and JS suites instead.
+CI runs the Rust suites with a coverage gate that fails if line or function coverage of the Rust core, or of the Node.js transport, drops below 100%. It also runs the wasm and JS suites on Node 20, 22 and 24, and checks formatting, dependencies (security advisories and licenses), API compatibility and the size budget. See [CONTRIBUTING.md](CONTRIBUTING.md#pull-requests). The JS-only bindings in `src/wasm/` and `src/http.rs` need a JS engine, so they're covered by the wasm and JS suites instead.
 
 Releases are published by CI when a version tag is pushed. See [CONTRIBUTING.md](CONTRIBUTING.md#releasing).
 

package/node.js

@@ -4,10 +4,262 @@
 // file: URLs. Here the module is compiled synchronously on import instead, so
 // the API is ready to use immediately; calling `init()` is optional and
 // returns the already-initialized module.
+//
+// It also registers a transport built on node:http/node:https. Node's global
+// fetch() implements browser semantics (WHATWG streams) on top of the same
+// sockets and is considerably slower; this transport only moves bytes.
+// Retries, timeouts, validation and decoding stay in the Rust core.
 import { readFileSync } from 'node:fs';
+import http from 'node:http';
+import https from 'node:https';
+import zlib from 'node:zlib';
 import { initSync } from './rust_fetch.js';
 
 initSync({ module: readFileSync(new URL('./rust_fetch_bg.wasm', import.meta.url)) });
 
+const MAX_REDIRECTS = 20;
+const REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+const ACCEPT_ENCODING = typeof zlib.zstdDecompressSync === 'function' ? 'gzip, deflate, br, zstd' : 'gzip, deflate, br';
+
+const textDecoder = new TextDecoder();
+// Response body types, numbered like `BodyType` in src/wasm/mod.rs
+const AUTO = 0;
+const JSON_BODY = 1;
+const TEXT = 2;
+const BINARY = 3;
+
+// Same rules as is_json_content_type / is_text_content_type in src/types.rs
+function mimeEssence(contentType) {
+  return (contentType ?? '').split(';')[0].trim().toLowerCase();
+}
+function isJsonType(essence) {
+  return essence === 'application/json' || essence.endsWith('+json');
+}
+function isTextType(essence) {
+  return (
+    essence.startsWith('text/') ||
+    essence.endsWith('+xml') ||
+    essence === 'application/xml' ||
+    essence === 'application/javascript' ||
+    essence === 'application/x-www-form-urlencoded'
+  );
+}
+
+function coded(error, code) {
+  error.code = code;
+  return error;
+}
+
+/**
+ * Decode a body like `decode_body` in src/wasm/transport.rs, in JS so the
+ * text never crosses into wasm. TextDecoder replaces invalid UTF-8 and strips
+ * a BOM; the length is checked first, since a BOM-only body is not empty.
+ */
+function decodeBody(bytes, contentType, bodyType) {
+  if (bytes.length === 0) return bodyType === TEXT ? '' : bodyType === BINARY ? new Uint8Array(0) : null;
+  const essence = mimeEssence(contentType);
+  const json = bodyType === JSON_BODY || (bodyType === AUTO && isJsonType(essence));
+  const text = json || bodyType === TEXT || (bodyType === AUTO && isTextType(essence));
+  if (!text) return bytes;
+  const decoded = textDecoder.decode(bytes);
+  if (!json) return decoded;
+  try {
+    return JSON.parse(decoded);
+  } catch (error) {
+    if (bodyType === AUTO) return decoded; // mislabelled responses fall back to text
+    throw coded(error, 'RUST_FETCH_PARSE');
+  }
+}
+
+/** Undo one Content-Encoding; unknown encodings are passed through, like fetch() */
+function decode(body, encoding) {
+  switch (encoding) {
+    case 'gzip':
+    case 'x-gzip':
+      return zlib.gunzipSync(body, { finishFlush: zlib.constants.Z_SYNC_FLUSH });
+    case 'deflate':
+      // Servers send both zlib-wrapped and raw deflate under this name
+      return body[0] === 0x78 ? zlib.inflateSync(body) : zlib.inflateRawSync(body);
+    case 'br':
+      return zlib.brotliDecompressSync(body);
+    case 'zstd':
+      return typeof zlib.zstdDecompressSync === 'function' ? zlib.zstdDecompressSync(body) : body;
+    default:
+      return body;
+  }
+}
+
+function decompress(body, contentEncoding) {
+  if (!contentEncoding || body.length === 0) return body;
+  // Encodings are listed in the order they were applied
+  const encodings = contentEncoding.toLowerCase().split(',').map((e) => e.trim()).filter((e) => e && e !== 'identity');
+  for (let i = encodings.length - 1; i >= 0; i--) body = decode(body, encodings[i]);
+  return body;
+}
+
+/** Response headers as one string per name; repeated headers joined with ", " */
+function flattenHeaders(raw) {
+  const headers = {};
+  for (const name in raw) {
+    const value = raw[name];
+    headers[name] = Array.isArray(value) ? value.join(', ') : value;
+  }
+  return headers;
+}
+
+/**
+ * A plain Uint8Array that owns its memory. Small Node Buffers share a pooled
+ * ArrayBuffer, so those are copied; larger ones are wrapped without copying.
+ */
+function ownedBytes(bytes) {
+  return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength
+    ? new Uint8Array(bytes.buffer)
+    : new Uint8Array(bytes);
+}
+
+function withoutHeaders(headers, names) {
+  const copy = { ...headers };
+  for (const name of names) delete copy[name];
+  return copy;
+}
+
+function send(state, method, url, headers, body, redirects, resolve, reject) {
+  if (state.cancelled) return;
+  const transport = url.protocol === 'https:' ? https : http;
+  const request = transport.request(url, { method, headers }, (response) => {
+    const status = response.statusCode;
+    const location = response.headers.location;
+
+    if (REDIRECT_STATUSES.has(status) && location) {
+      response.resume();
+      if (redirects >= MAX_REDIRECTS) return reject(new TypeError(`Too many redirects (more than ${MAX_REDIRECTS})`));
+      let next;
+      try {
+        next = new URL(location, url);
+      } catch {
+        return reject(new TypeError(`Invalid redirect location: ${location}`));
+      }
+      if (next.protocol !== 'http:' && next.protocol !== 'https:') {
+        return reject(new TypeError(`Unsupported redirect to ${next.protocol}`));
+      }
+      // Same rules as fetch(): 303, and 301/302 after POST, become a bodiless GET
+      let nextMethod = method;
+      let nextBody = body;
+      let nextHeaders = headers;
+      if ((status === 303 && method !== 'GET' && method !== 'HEAD') || ((status === 301 || status === 302) && method === 'POST')) {
+        nextMethod = 'GET';
+        nextBody = undefined;
+        nextHeaders = withoutHeaders(nextHeaders, ['content-type', 'content-length', 'content-encoding', 'content-language', 'content-location']);
+      }
+      // Never forward credentials to another origin
+      if (next.origin !== url.origin) {
+        nextHeaders = withoutHeaders(nextHeaders, ['authorization', 'cookie', 'proxy-authorization']);
+      }
+      return send(state, nextMethod, next, nextHeaders, nextBody, redirects + 1, resolve, reject);
+    }
+
+    // With a Content-Length, fill one preallocated buffer (a single copy);
+    // otherwise collect chunks and join them at the end.
+    const expected = Number(response.headers['content-length']);
+    const preallocated = !response.headers['content-encoding'] && Number.isSafeInteger(expected) && expected > 0 && expected <= 512 * 1024 * 1024;
+    const buffer = preallocated ? new Uint8Array(expected) : undefined;
+    let received = 0;
+    const chunks = [];
+    response.on('data', (chunk) => {
+      if (buffer && received + chunk.length <= expected) buffer.set(chunk, received);
+      else chunks.push(chunk);
+      received += chunk.length;
+    });
+    response.on('error', reject);
+    // A socket closed mid-body may emit 'close' without 'end' (a settled promise ignores this)
+    response.on('close', () => {
+      if (!response.complete) reject(new TypeError('The connection closed before the response body was complete'));
+    });
+    response.on('end', () => {
+      if (!response.complete) return reject(new TypeError('The connection closed before the response body was complete'));
+      try {
+        let body;
+        if (buffer && received === expected && chunks.length === 0) {
+          body = buffer;
+        } else {
+          const raw = buffer ? Buffer.concat([buffer.subarray(0, Math.min(received, expected)), ...chunks]) : Buffer.concat(chunks);
+          body = ownedBytes(method === 'HEAD' ? raw : decompress(raw, response.headers['content-encoding']));
+        }
+        resolve({ status, url: url.href, headers: flattenHeaders(response.headers), body });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+  request.on('error', reject);
+  request.end(body);
+  state.request = request;
+}
+
+/**
+ * One attempt, called by the Rust core with
+ * `{ method, url, headers, body?, timeout?, bodyType }`. Resolves to the
+ * finished `{ status, statusText, ok, url, headers, body }` (the core fills
+ * in statusText). Rejects with code RUST_FETCH_TIMEOUT or RUST_FETCH_PARSE,
+ * or any other error for network failures.
+ *
+ * The promise has a `cancel()` method, which the core calls only when it
+ * abandons an attempt (e.g. AbortSignal); this is much cheaper than wiring an
+ * AbortSignal into every request.
+ */
+function nodeTransport(request) {
+  const state = { cancelled: false, request: undefined, bodyType: request.bodyType ?? AUTO };
+  let timer;
+  const promise = new Promise((resolve, reject) => {
+    if (request.timeout > 0) {
+      // Covers the whole attempt: connecting, redirects and reading the body
+      timer = setTimeout(() => {
+        cancel();
+        reject(coded(new Error(`Request timeout after ${request.timeout}ms`), 'RUST_FETCH_TIMEOUT'));
+      }, request.timeout);
+    }
+    let url;
+    try {
+      url = new URL(request.url);
+    } catch (error) {
+      clearTimeout(timer);
+      return reject(error);
+    }
+    const headers = { ...request.headers };
+    headers['accept'] ??= '*/*';
+    headers['accept-encoding'] ??= ACCEPT_ENCODING;
+    headers['user-agent'] ??= 'rust-fetch';
+    if (request.body) headers['content-length'] ??= String(request.body.length);
+    const settle = (fn) => (value) => {
+      clearTimeout(timer);
+      fn(value);
+    };
+    send(state, request.method, url, headers, request.body, 0, settle(resolve), settle(reject));
+  });
+  const cancel = () => {
+    state.cancelled = true;
+    state.request?.destroy();
+  };
+  // Decode only after the socket's event handlers have returned: decoding
+  // inside them keeps the raw chunks and stream state alive during
+  // JSON.parse, which costs several times more garbage collection.
+  const finished = promise.then((response) => finishResponse(response, state.bodyType));
+  finished.cancel = () => {
+    clearTimeout(timer);
+    cancel();
+  };
+  return finished;
+}
+
+/** The response object handed to the Rust core (which fills in statusText) */
+function finishResponse({ status, url, headers, body }, bodyType) {
+  const ok = status >= 200 && status < 300;
+  // Error statuses carry their body as text (for HttpError.body)
+  const decoded = ok ? decodeBody(body, headers['content-type'], bodyType) : decodeBody(body, '', TEXT);
+  return { status, statusText: '', ok, url, headers, body: decoded };
+}
+
+globalThis[Symbol.for('rust-fetch.transport')] = nodeTransport;
+
 export { default } from './rust_fetch.js';
 export * from './rust_fetch.js';

package/package.json

@@ -4,8 +4,8 @@
   "collaborators": [
     "Asem Qaffaf <asem@qaffaf.com>"
   ],
-  "description": "A high-performance HTTP client for JavaScript/TypeScript powered by WebAssembly, for browsers and Node.js",
-  "version": "2.0.0",
+  "description": "A reliable HTTP client for JavaScript and TypeScript, written in Rust and compiled to WebAssembly: timeouts, retries, typed errors and interceptors, faster than fetch() in Node.js",
+  "version": "2.1.0",
   "license": "MIT OR Apache-2.0",
   "repository": {
     "type": "git",

package/rust_fetch.js

@@ -513,6 +513,10 @@ function __wbg_get_imports() {
         __wbg_append_1938ed58fb5613b8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
+        __wbg_arrayBuffer_f07be74819944ea2: function() { return handleError(function (arg0) {
+            const ret = arg0.arrayBuffer();
+            return ret;
+        }, arguments); },
         __wbg_body_4e088733babc630d: function(arg0) {
             const ret = arg0.body;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
@@ -525,6 +529,10 @@ function __wbg_get_imports() {
             const ret = arg0.byobRequest;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
+        __wbg_byteLength_27689b065d089962: function(arg0) {
+            const ret = arg0.byteLength;
+            return ret;
+        },
         __wbg_byteLength_9f985b8373f1f3fe: function(arg0) {
             const ret = arg0.byteLength;
             return ret;
@@ -553,7 +561,7 @@ function __wbg_get_imports() {
             const ret = clearTimeout(arg0);
             return ret;
         },
-        __wbg_clearTimeout_80e0bf42f165386a: function(arg0) {
+        __wbg_clearTimeout_2d18004c33139d44: function(arg0) {
             clearTimeout(arg0);
         },
         __wbg_close_185286988f30f252: function() { return handleError(function (arg0) {
@@ -562,6 +570,10 @@ function __wbg_get_imports() {
         __wbg_close_748f26698dabe269: function() { return handleError(function (arg0) {
             arg0.close();
         }, arguments); },
+        __wbg_decode_0be77be735437c76: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.decode(arg1);
+            return ret;
+        }, arguments); },
         __wbg_done_b41a1d26cdb37fb6: function(arg0) {
             const ret = arg0.done;
             return ret;
@@ -577,6 +589,10 @@ function __wbg_get_imports() {
             const ret = Object.entries(arg0);
             return ret;
         },
+        __wbg_fetch_43bae44b7171a171: function() { return handleError(function (arg0) {
+            const ret = fetch(arg0);
+            return ret;
+        }, arguments); },
         __wbg_fetch_7a37768ab67c5bd8: function(arg0) {
             const ret = fetch(arg0);
             return ret;
@@ -585,6 +601,14 @@ function __wbg_get_imports() {
             const ret = arg0.fetch(arg1);
             return ret;
         },
+        __wbg_for_beb5dc4e908dd8b8: function(arg0, arg1) {
+            const ret = Symbol.for(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_fromEntries_5159142be68954c3: function() { return handleError(function (arg0) {
+            const ret = Object.fromEntries(arg0);
+            return ret;
+        }, arguments); },
         __wbg_from_296ca31f8d0f1c52: function(arg0) {
             const ret = Array.from(arg0);
             return ret;
@@ -609,6 +633,13 @@ function __wbg_get_imports() {
             const ret = arg0.done;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
+        __wbg_get_f75619e20cb68514: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg1.get(getStringFromWasm0(arg2, arg3));
+            var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            var len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        }, arguments); },
         __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -707,6 +738,10 @@ function __wbg_get_imports() {
             const ret = new Headers();
             return ret;
         }, arguments); },
+        __wbg_new_cdac6c2ae368ec54: function() {
+            const ret = new TextDecoder();
+            return ret;
+        },
         __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
@@ -753,13 +788,25 @@ function __wbg_get_imports() {
             const ret = arg0.next();
             return ret;
         }, arguments); },
+        __wbg_of_20798cb14708764f: function(arg0, arg1) {
+            const ret = Array.of(arg0, arg1);
+            return ret;
+        },
         __wbg_parse_0fc53dead14b3b42: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
+        __wbg_parse_33ce4953982abfa3: function() { return handleError(function (arg0) {
+            const ret = JSON.parse(arg0);
+            return ret;
+        }, arguments); },
         __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
+            const ret = arg0.push(arg1);
+            return ret;
+        },
         __wbg_queueMicrotask_9833f9a49df95a49: function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
@@ -792,7 +839,7 @@ function __wbg_get_imports() {
         __wbg_respond_c102fabcc79e5ef0: function() { return handleError(function (arg0, arg1) {
             arg0.respond(arg1 >>> 0);
         }, arguments); },
-        __wbg_setTimeout_52f32a16f2242504: function(arg0, arg1) {
+        __wbg_setTimeout_61cdece84a7288cf: function(arg0, arg1) {
             const ret = setTimeout(arg0, arg1);
             return ret;
         },
@@ -807,6 +854,9 @@ function __wbg_get_imports() {
         __wbg_set_575d3ddb70fe831d: function(arg0, arg1, arg2) {
             arg0.set(getArrayU8FromWasm0(arg1, arg2));
         },
+        __wbg_set_af5932e3f78b5648: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
         __wbg_set_body_1fb0f1008bfc7df6: function(arg0, arg1) {
             arg0.body = arg1;
         },
@@ -900,17 +950,17 @@ function __wbg_get_imports() {
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 211, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 220, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6b82e471f4a4091b___convert__closures_____invoke___wasm_bindgen_6b82e471f4a4091b___JsValue______true_);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 331, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 340, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6b82e471f4a4091b___convert__closures_____invoke___wasm_bindgen_6b82e471f4a4091b___JsValue__core_37ee0ce0c4cd57d5___result__Result_____wasm_bindgen_6b82e471f4a4091b___JsError___true_);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 176, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 185, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen_6b82e471f4a4091b___convert__closures_____invoke_______true_);
             return ret;
         },