@xberg-io/liter-llm-wasm 2.1.0 → 2.1.2

package/liter_llm_wasm.js

@@ -158,6 +158,9 @@ export class WasmAssistantMessage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmassistantmessage_free(ptr, 0);
     }
+    clearFunctionCall() {
+        wasm.wasmassistantmessage_clearFunctionCall(this.__wbg_ptr);
+    }
     /**
      * @returns {string | undefined}
      */
@@ -197,6 +200,11 @@ export class WasmAssistantMessage {
         return v1;
     }
     /**
+     * Takes ownership of `functionCall`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [content]
      * @param {string | null} [name]
      * @param {WasmToolCall[] | null} [toolCalls]
@@ -307,15 +315,11 @@ export class WasmAssistantMessage {
         wasm.wasmassistantmessage_set_content(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmFunctionCall | null} [value]
+     * @param {WasmFunctionCall} value
      */
     set functionCall(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmFunctionCall);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmassistantmessage_set_functionCall(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmFunctionCall);
+        wasm.wasmassistantmessage_set_functionCall(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -405,6 +409,12 @@ export class WasmAssistantPart {
         const ret = wasm.wasmassistantpart_audio(this.__wbg_ptr);
         return ret === 0 ? undefined : WasmAudioContent.__wrap(ret);
     }
+    clearAudio() {
+        wasm.wasmassistantpart_clearAudio(this.__wbg_ptr);
+    }
+    clearImageUrl() {
+        wasm.wasmassistantpart_clearImageUrl(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmAssistantPart}
      */
@@ -438,26 +448,18 @@ export class WasmAssistantPart {
         return v1;
     }
     /**
-     * @param {WasmAudioContent | null} [value]
+     * @param {WasmAudioContent} value
      */
     set audio(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmAudioContent);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmassistantpart_set_audio(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmAudioContent);
+        wasm.wasmassistantpart_set_audio(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmImageUrl | null} [value]
+     * @param {WasmImageUrl} value
      */
     set imageUrl(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmImageUrl);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmassistantpart_set_imageUrl(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmImageUrl);
+        wasm.wasmassistantpart_set_imageUrl(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -1024,6 +1026,9 @@ export class WasmBatchObject {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmbatchobject_free(ptr, 0);
     }
+    clearRequestCounts() {
+        wasm.wasmbatchobject_clearRequestCounts(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint | undefined}
      */
@@ -1139,6 +1144,11 @@ export class WasmBatchObject {
         return ret;
     }
     /**
+     * Takes ownership of `requestCounts`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [id]
      * @param {string | null} [object]
      * @param {string | null} [endpoint]
@@ -1300,15 +1310,11 @@ export class WasmBatchObject {
         wasm.wasmbatchobject_set_outputFileId(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmBatchRequestCounts | null} [value]
+     * @param {WasmBatchRequestCounts} value
      */
     set requestCounts(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmBatchRequestCounts);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmbatchobject_set_requestCounts(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmBatchRequestCounts);
+        wasm.wasmbatchobject_set_requestCounts(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmBatchStatus} value
@@ -1742,6 +1748,9 @@ export class WasmChatCompletionChunk {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    clearUsage() {
+        wasm.wasmchatcompletionchunk_clearUsage(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint}
      */
@@ -1787,6 +1796,11 @@ export class WasmChatCompletionChunk {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [id]
      * @param {string | null} [object]
      * @param {bigint | null} [created]
@@ -1901,15 +1915,11 @@ export class WasmChatCompletionChunk {
         wasm.wasmchatcompletionchunk_set_systemFingerprint(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmUsage | null} [value]
+     * @param {WasmUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmchatcompletionchunk_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmUsage);
+        wasm.wasmchatcompletionchunk_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @returns {string | undefined}
@@ -1960,6 +1970,9 @@ export class WasmChatCompletionRequest {
         const ret = wasm.wasmchatcompletionrequest_audio(this.__wbg_ptr);
         return ret;
     }
+    clearStreamOptions() {
+        wasm.wasmchatcompletionrequest_clearStreamOptions(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmChatCompletionRequest}
      */
@@ -2058,6 +2071,11 @@ export class WasmChatCompletionRequest {
         return ret === Number.MAX_SAFE_INTEGER ? undefined : ret;
     }
     /**
+     * Takes ownership of `streamOptions`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [model]
      * @param {any | null} [messages]
      * @param {number | null} [temperature]
@@ -2302,15 +2320,11 @@ export class WasmChatCompletionRequest {
         wasm.wasmchatcompletionrequest_set_store(this.__wbg_ptr, isLikeNone(value) ? 0xFFFFFF : value ? 1 : 0);
     }
     /**
-     * @param {WasmStreamOptions | null} [value]
+     * @param {WasmStreamOptions} value
      */
     set streamOptions(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmStreamOptions);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmchatcompletionrequest_set_streamOptions(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmStreamOptions);
+        wasm.wasmchatcompletionrequest_set_streamOptions(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {boolean | null} [value]
@@ -2478,6 +2492,9 @@ export class WasmChatCompletionResponse {
         wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
         return v1;
     }
+    clearUsage() {
+        wasm.wasmchatcompletionresponse_clearUsage(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint}
      */
@@ -2523,6 +2540,11 @@ export class WasmChatCompletionResponse {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [id]
      * @param {string | null} [object]
      * @param {bigint | null} [created]
@@ -2637,15 +2659,11 @@ export class WasmChatCompletionResponse {
         wasm.wasmchatcompletionresponse_set_systemFingerprint(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmUsage | null} [value]
+     * @param {WasmUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmchatcompletionresponse_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmUsage);
+        wasm.wasmchatcompletionresponse_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @returns {string | undefined}
@@ -2715,8 +2733,7 @@ export class WasmChatCompletionTool {
      */
     constructor(toolType, _function) {
         _assertClass(_function, WasmFunctionDefinition);
-        var ptr0 = _function.__destroy_into_raw();
-        const ret = wasm.wasmchatcompletiontool_new(toolType, ptr0);
+        const ret = wasm.wasmchatcompletiontool_new(toolType, _function.__wbg_ptr);
         this.__wbg_ptr = ret;
         WasmChatCompletionToolFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -2726,8 +2743,7 @@ export class WasmChatCompletionTool {
      */
     set function(value) {
         _assertClass(value, WasmFunctionDefinition);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmchatcompletiontool_set_function(this.__wbg_ptr, ptr0);
+        wasm.wasmchatcompletiontool_set_function(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmToolType} value
@@ -2820,6 +2836,11 @@ export class WasmChoice {
         return WasmAssistantMessage.__wrap(ret);
     }
     /**
+     * Takes ownership of `message`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number | null} [index]
      * @param {WasmAssistantMessage | null} [message]
      * @param {WasmFinishReason | null} [finishReason]
@@ -2859,8 +2880,7 @@ export class WasmChoice {
      */
     set message(value) {
         _assertClass(value, WasmAssistantMessage);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmchoice_set_message(this.__wbg_ptr, ptr0);
+        wasm.wasmchoice_set_message(this.__wbg_ptr, value.__wbg_ptr);
     }
 }
 if (Symbol.dispose) WasmChoice.prototype[Symbol.dispose] = WasmChoice.prototype.free;
@@ -2885,6 +2905,15 @@ export class WasmContentPart {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmcontentpart_free(ptr, 0);
     }
+    clearDocument() {
+        wasm.wasmcontentpart_clearDocument(this.__wbg_ptr);
+    }
+    clearImageUrl() {
+        wasm.wasmcontentpart_clearImageUrl(this.__wbg_ptr);
+    }
+    clearInputAudio() {
+        wasm.wasmcontentpart_clearInputAudio(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmContentPart}
      */
@@ -2920,37 +2949,25 @@ export class WasmContentPart {
         return this;
     }
     /**
-     * @param {WasmDocumentContent | null} [value]
+     * @param {WasmDocumentContent} value
      */
     set document(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmDocumentContent);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmcontentpart_set_document(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmDocumentContent);
+        wasm.wasmcontentpart_set_document(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmImageUrl | null} [value]
+     * @param {WasmImageUrl} value
      */
     set imageUrl(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmImageUrl);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmcontentpart_set_imageUrl(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmImageUrl);
+        wasm.wasmcontentpart_set_imageUrl(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmAudioContent | null} [value]
+     * @param {WasmAudioContent} value
      */
     set inputAudio(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmAudioContent);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmcontentpart_set_inputAudio(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmAudioContent);
+        wasm.wasmcontentpart_set_inputAudio(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -4802,6 +4819,9 @@ export class WasmEmbeddingContentPart {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmembeddingcontentpart_free(ptr, 0);
     }
+    clearImageUrl() {
+        wasm.wasmembeddingcontentpart_clearImageUrl(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmEmbeddingContentPart}
      */
@@ -4843,15 +4863,11 @@ export class WasmEmbeddingContentPart {
         wasm.wasmembeddingcontentpart_set_imageBase64(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmImageUrl | null} [value]
+     * @param {WasmImageUrl} value
      */
     set imageUrl(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmImageUrl);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmembeddingcontentpart_set_imageUrl(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmImageUrl);
+        wasm.wasmembeddingcontentpart_set_imageUrl(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -5166,6 +5182,9 @@ export class WasmEmbeddingResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmembeddingresponse_free(ptr, 0);
     }
+    clearUsage() {
+        wasm.wasmembeddingresponse_clearUsage(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmEmbeddingObject[]}
      */
@@ -5198,6 +5217,11 @@ export class WasmEmbeddingResponse {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string} object
      * @param {WasmEmbeddingObject[]} data
      * @param {string} model
@@ -5260,15 +5284,11 @@ export class WasmEmbeddingResponse {
         wasm.wasmembeddingresponse_set_object(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmUsage | null} [value]
+     * @param {WasmUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmembeddingresponse_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmUsage);
+        wasm.wasmembeddingresponse_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @returns {WasmUsage | undefined}
@@ -6712,6 +6732,21 @@ export class WasmLlmConfig {
         const ret = wasm.wasmllmconfig_cache(this.__wbg_ptr);
         return ret === 0 ? undefined : WasmLlmCacheConfig.__wrap(ret);
     }
+    clearBedrock() {
+        wasm.wasmllmconfig_clearBedrock(this.__wbg_ptr);
+    }
+    clearBudget() {
+        wasm.wasmllmconfig_clearBudget(this.__wbg_ptr);
+    }
+    clearCache() {
+        wasm.wasmllmconfig_clearCache(this.__wbg_ptr);
+    }
+    clearInFlightLimit() {
+        wasm.wasmllmconfig_clearInFlightLimit(this.__wbg_ptr);
+    }
+    clearRateLimit() {
+        wasm.wasmllmconfig_clearRateLimit(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint | undefined}
      */
@@ -6791,6 +6826,11 @@ export class WasmLlmConfig {
         }
     }
     /**
+     * Takes ownership of `cache`, `budget`, `rateLimit`, `inFlightLimit`, `bedrock`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [model]
      * @param {string | null} [apiKey]
      * @param {string | null} [baseUrl]
@@ -6881,37 +6921,25 @@ export class WasmLlmConfig {
         wasm.wasmllmconfig_set_baseUrl(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmBedrockConfig | null} [value]
+     * @param {WasmBedrockConfig} value
      */
     set bedrock(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmBedrockConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_bedrock(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmBedrockConfig);
+        wasm.wasmllmconfig_set_bedrock(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmLlmBudgetConfig | null} [value]
+     * @param {WasmLlmBudgetConfig} value
      */
     set budget(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmLlmBudgetConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_budget(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmLlmBudgetConfig);
+        wasm.wasmllmconfig_set_budget(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
-     * @param {WasmLlmCacheConfig | null} [value]
+     * @param {WasmLlmCacheConfig} value
      */
     set cache(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmLlmCacheConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_cache(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmLlmCacheConfig);
+        wasm.wasmllmconfig_set_cache(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {bigint | null} [value]
@@ -6938,15 +6966,11 @@ export class WasmLlmConfig {
         wasm.wasmllmconfig_set_healthCheckSecs(this.__wbg_ptr, !isLikeNone(value), isLikeNone(value) ? BigInt(0) : value);
     }
     /**
-     * @param {WasmLlmInFlightLimitConfig | null} [value]
+     * @param {WasmLlmInFlightLimitConfig} value
      */
     set inFlightLimit(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmLlmInFlightLimitConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_inFlightLimit(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmLlmInFlightLimitConfig);
+        wasm.wasmllmconfig_set_inFlightLimit(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {boolean | null} [value]
@@ -6983,15 +7007,11 @@ export class WasmLlmConfig {
         wasm.wasmllmconfig_set_providers(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmLlmRateLimitConfig | null} [value]
+     * @param {WasmLlmRateLimitConfig} value
      */
     set rateLimit(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmLlmRateLimitConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmllmconfig_set_rateLimit(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmLlmRateLimitConfig);
+        wasm.wasmllmconfig_set_rateLimit(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {number | null} [value]
@@ -8652,10 +8672,8 @@ export class WasmModerationResult {
      */
     constructor(flagged, categories, categoryScores) {
         _assertClass(categories, WasmModerationCategories);
-        var ptr0 = categories.__destroy_into_raw();
         _assertClass(categoryScores, WasmModerationCategoryScores);
-        var ptr1 = categoryScores.__destroy_into_raw();
-        const ret = wasm.wasmmoderationresult_new(flagged, ptr0, ptr1);
+        const ret = wasm.wasmmoderationresult_new(flagged, categories.__wbg_ptr, categoryScores.__wbg_ptr);
         this.__wbg_ptr = ret;
         WasmModerationResultFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -8665,16 +8683,14 @@ export class WasmModerationResult {
      */
     set categories(value) {
         _assertClass(value, WasmModerationCategories);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmmoderationresult_set_categories(this.__wbg_ptr, ptr0);
+        wasm.wasmmoderationresult_set_categories(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmModerationCategoryScores} value
      */
     set categoryScores(value) {
         _assertClass(value, WasmModerationCategoryScores);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmmoderationresult_set_categoryScores(this.__wbg_ptr, ptr0);
+        wasm.wasmmoderationresult_set_categoryScores(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {boolean} value
@@ -8923,6 +8939,9 @@ export class WasmOcrPage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmocrpage_free(ptr, 0);
     }
+    clearDimensions() {
+        wasm.wasmocrpage_clearDimensions(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmOcrPage}
      */
@@ -8967,6 +8986,11 @@ export class WasmOcrPage {
         }
     }
     /**
+     * Takes ownership of `dimensions`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number} index
      * @param {string} markdown
      * @param {WasmOcrImage[] | null} [images]
@@ -8988,15 +9012,11 @@ export class WasmOcrPage {
         return this;
     }
     /**
-     * @param {WasmPageDimensions | null} [value]
+     * @param {WasmPageDimensions} value
      */
     set dimensions(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmPageDimensions);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmocrpage_set_dimensions(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmPageDimensions);
+        wasm.wasmocrpage_set_dimensions(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmOcrImage[] | null} [value]
@@ -9158,6 +9178,9 @@ export class WasmOcrResponse {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmocrresponse_free(ptr, 0);
     }
+    clearUsage() {
+        wasm.wasmocrresponse_clearUsage(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmOcrResponse}
      */
@@ -9181,6 +9204,11 @@ export class WasmOcrResponse {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {WasmOcrPage[]} pages
      * @param {string} model
      * @param {WasmUsage | null} [usage]
@@ -9226,15 +9254,11 @@ export class WasmOcrResponse {
         wasm.wasmocrresponse_set_pages(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmUsage | null} [value]
+     * @param {WasmUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmocrresponse_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmUsage);
+        wasm.wasmocrresponse_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @returns {WasmUsage | undefined}
@@ -9571,6 +9595,9 @@ export class WasmProviderConfig {
         }
         return v1;
     }
+    clearAuth() {
+        wasm.wasmproviderconfig_clearAuth(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmProviderConfig}
      */
@@ -9630,6 +9657,11 @@ export class WasmProviderConfig {
         }
     }
     /**
+     * Takes ownership of `auth`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string} name
      * @param {string | null} [displayName]
      * @param {string | null} [baseUrl]
@@ -9667,15 +9699,11 @@ export class WasmProviderConfig {
         return ret;
     }
     /**
-     * @param {WasmAuthConfig | null} [value]
+     * @param {WasmAuthConfig} value
      */
     set auth(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmAuthConfig);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmproviderconfig_set_auth(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmAuthConfig);
+        wasm.wasmproviderconfig_set_auth(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -10001,6 +10029,9 @@ export class WasmRerankResult {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmrerankresult_free(ptr, 0);
     }
+    clearDocument() {
+        wasm.wasmrerankresult_clearDocument(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmRerankResult}
      */
@@ -10023,6 +10054,11 @@ export class WasmRerankResult {
         return ret >>> 0;
     }
     /**
+     * Takes ownership of `document`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number} index
      * @param {number} relevanceScore
      * @param {WasmRerankResultDocument | null} [document]
@@ -10046,15 +10082,11 @@ export class WasmRerankResult {
         return ret;
     }
     /**
-     * @param {WasmRerankResultDocument | null} [value]
+     * @param {WasmRerankResultDocument} value
      */
     set document(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmRerankResultDocument);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmrerankresult_set_document(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmRerankResultDocument);
+        wasm.wasmrerankresult_set_document(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {number} value
@@ -10172,6 +10204,9 @@ export class WasmResponseFormat {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmresponseformat_free(ptr, 0);
     }
+    clearJsonSchema() {
+        wasm.wasmresponseformat_clearJsonSchema(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmResponseFormat}
      */
@@ -10193,15 +10228,11 @@ export class WasmResponseFormat {
         return this;
     }
     /**
-     * @param {WasmJsonSchemaFormat | null} [value]
+     * @param {WasmJsonSchemaFormat} value
      */
     set jsonSchema(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmJsonSchemaFormat);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmresponseformat_set_jsonSchema(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmJsonSchemaFormat);
+        wasm.wasmresponseformat_set_jsonSchema(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string} value
@@ -10249,6 +10280,9 @@ export class WasmResponseObject {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmresponseobject_free(ptr, 0);
     }
+    clearUsage() {
+        wasm.wasmresponseobject_clearUsage(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint}
      */
@@ -10301,6 +10335,11 @@ export class WasmResponseObject {
         }
     }
     /**
+     * Takes ownership of `usage`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [id]
      * @param {string | null} [object]
      * @param {bigint | null} [createdAt]
@@ -10408,15 +10447,11 @@ export class WasmResponseObject {
         wasm.wasmresponseobject_set_status(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmResponseUsage | null} [value]
+     * @param {WasmResponseUsage} value
      */
     set usage(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmResponseUsage);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmresponseobject_set_usage(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmResponseUsage);
+        wasm.wasmresponseobject_set_usage(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @returns {string}
@@ -11184,6 +11219,11 @@ export class WasmSpecificToolChoice {
         return WasmSpecificFunction.__wrap(ret);
     }
     /**
+     * Takes ownership of `function`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {WasmToolType | null} [choiceType]
      * @param {WasmSpecificFunction | null} [_function]
      */
@@ -11209,8 +11249,7 @@ export class WasmSpecificToolChoice {
      */
     set function(value) {
         _assertClass(value, WasmSpecificFunction);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmspecifictoolchoice_set_function(this.__wbg_ptr, ptr0);
+        wasm.wasmspecifictoolchoice_set_function(this.__wbg_ptr, value.__wbg_ptr);
     }
 }
 if (Symbol.dispose) WasmSpecificToolChoice.prototype[Symbol.dispose] = WasmSpecificToolChoice.prototype.free;
@@ -11275,6 +11314,11 @@ export class WasmStreamChoice {
         return ret >>> 0;
     }
     /**
+     * Takes ownership of `delta`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number | null} [index]
      * @param {WasmStreamDelta | null} [delta]
      * @param {WasmFinishReason | null} [finishReason]
@@ -11295,8 +11339,7 @@ export class WasmStreamChoice {
      */
     set delta(value) {
         _assertClass(value, WasmStreamDelta);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmstreamchoice_set_delta(this.__wbg_ptr, ptr0);
+        wasm.wasmstreamchoice_set_delta(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {WasmFinishReason | null} [value]
@@ -11333,6 +11376,9 @@ export class WasmStreamDelta {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmstreamdelta_free(ptr, 0);
     }
+    clearFunctionCall() {
+        wasm.wasmstreamdelta_clearFunctionCall(this.__wbg_ptr);
+    }
     /**
      * @returns {string | undefined}
      */
@@ -11360,6 +11406,11 @@ export class WasmStreamDelta {
         return ret === 0 ? undefined : WasmStreamFunctionCall.__wrap(ret);
     }
     /**
+     * Takes ownership of `functionCall`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {string | null} [role]
      * @param {string | null} [content]
      * @param {WasmStreamToolCall[] | null} [toolCalls]
@@ -11433,15 +11484,11 @@ export class WasmStreamDelta {
         wasm.wasmstreamdelta_set_content(this.__wbg_ptr, ptr0, len0);
     }
     /**
-     * @param {WasmStreamFunctionCall | null} [value]
+     * @param {WasmStreamFunctionCall} value
      */
     set functionCall(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmStreamFunctionCall);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmstreamdelta_set_functionCall(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmStreamFunctionCall);
+        wasm.wasmstreamdelta_set_functionCall(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -11673,6 +11720,9 @@ export class WasmStreamToolCall {
         }
         return v1;
     }
+    clearFunction() {
+        wasm.wasmstreamtoolcall_clearFunction(this.__wbg_ptr);
+    }
     /**
      * @returns {WasmStreamToolCall}
      */
@@ -11707,6 +11757,11 @@ export class WasmStreamToolCall {
         return ret >>> 0;
     }
     /**
+     * Takes ownership of `function`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {number | null} [index]
      * @param {string | null} [id]
      * @param {WasmToolType | null} [callType]
@@ -11732,15 +11787,11 @@ export class WasmStreamToolCall {
         wasm.wasmstreamtoolcall_set_callType(this.__wbg_ptr, isLikeNone(value) ? 1 : value);
     }
     /**
-     * @param {WasmStreamFunctionCall | null} [value]
+     * @param {WasmStreamFunctionCall} value
      */
     set function(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmStreamFunctionCall);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmstreamtoolcall_set_function(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmStreamFunctionCall);
+        wasm.wasmstreamtoolcall_set_function(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string | null} [value]
@@ -11913,8 +11964,7 @@ export class WasmToolCall {
         const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
         _assertClass(_function, WasmFunctionCall);
-        var ptr1 = _function.__destroy_into_raw();
-        const ret = wasm.wasmtoolcall_new(ptr0, len0, callType, ptr1);
+        const ret = wasm.wasmtoolcall_new(ptr0, len0, callType, _function.__wbg_ptr);
         this.__wbg_ptr = ret;
         WasmToolCallFinalization.register(this, this.__wbg_ptr, this);
         return this;
@@ -11930,8 +11980,7 @@ export class WasmToolCall {
      */
     set function(value) {
         _assertClass(value, WasmFunctionCall);
-        var ptr0 = value.__destroy_into_raw();
-        wasm.wasmtoolcall_set_function(this.__wbg_ptr, ptr0);
+        wasm.wasmtoolcall_set_function(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {string} value
@@ -12318,6 +12367,9 @@ export class WasmUsage {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_wasmusage_free(ptr, 0);
     }
+    clearPromptTokensDetails() {
+        wasm.wasmusage_clearPromptTokensDetails(this.__wbg_ptr);
+    }
     /**
      * @returns {bigint}
      */
@@ -12333,6 +12385,11 @@ export class WasmUsage {
         return WasmUsage.__wrap(ret);
     }
     /**
+     * Takes ownership of `promptTokensDetails`.
+     * wasm-bindgen lowers a by-value class argument through `__destroy_into_raw()`, so each
+     * of those handles is dead once this returns. Passing a freshly built value is fine. To
+     * keep a handle you already hold, build with `default()` and assign the property instead:
+     * the generated setter borrows and leaves your handle alive.
      * @param {bigint | null} [promptTokens]
      * @param {bigint | null} [completionTokens]
      * @param {bigint | null} [totalTokens]
@@ -12370,15 +12427,11 @@ export class WasmUsage {
         wasm.wasmusage_set_completionTokens(this.__wbg_ptr, value);
     }
     /**
-     * @param {WasmPromptTokensDetails | null} [value]
+     * @param {WasmPromptTokensDetails} value
      */
     set promptTokensDetails(value) {
-        let ptr0 = 0;
-        if (!isLikeNone(value)) {
-            _assertClass(value, WasmPromptTokensDetails);
-            ptr0 = value.__destroy_into_raw();
-        }
-        wasm.wasmusage_set_promptTokensDetails(this.__wbg_ptr, ptr0);
+        _assertClass(value, WasmPromptTokensDetails);
+        wasm.wasmusage_set_promptTokensDetails(this.__wbg_ptr, value.__wbg_ptr);
     }
     /**
      * @param {bigint} value
@@ -12961,68 +13014,68 @@ export function unregisterCustomProvider(name) {
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
-        __wbg_Error_67e7344beaa85059: function(arg0, arg1) {
+        __wbg_Error_30c8987f7c2ed4e2: function(arg0, arg1) {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg___wbindgen_bigint_get_as_i64_b482365c149396c8: function(arg0, arg1) {
+        __wbg___wbindgen_bigint_get_as_i64_a2383202b9353e4c: function(arg0, arg1) {
             const v = arg1;
             const ret = typeof(v) === 'bigint' ? v : undefined;
             getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
         },
-        __wbg___wbindgen_boolean_get_7a12af2b3f899c5a: function(arg0) {
+        __wbg___wbindgen_boolean_get_5b446f51afd21013: function(arg0) {
             const v = arg0;
             const ret = typeof(v) === 'boolean' ? v : undefined;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg___wbindgen_debug_string_0e68cf47c9cbd9b0: function(arg0, arg1) {
+        __wbg___wbindgen_debug_string_4687d8d8c2017d52: function(arg0, arg1) {
             const ret = debugString(arg1);
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_in_50072d4d6e45c193: function(arg0, arg1) {
+        __wbg___wbindgen_in_92f62ee1427d9e49: function(arg0, arg1) {
             const ret = arg0 in arg1;
             return ret;
         },
-        __wbg___wbindgen_is_bigint_60fc0336cb14f5d7: function(arg0) {
+        __wbg___wbindgen_is_bigint_b123553bed3bb382: function(arg0) {
             const ret = typeof(arg0) === 'bigint';
             return ret;
         },
-        __wbg___wbindgen_is_function_fcda5e3902d732fe: function(arg0) {
+        __wbg___wbindgen_is_function_1f9d30630b8b1d3d: function(arg0) {
             const ret = typeof(arg0) === 'function';
             return ret;
         },
-        __wbg___wbindgen_is_object_edb6b15aa3afe12e: function(arg0) {
+        __wbg___wbindgen_is_object_3c45d4f2dde4e749: function(arg0) {
             const val = arg0;
             const ret = typeof(val) === 'object' && val !== null;
             return ret;
         },
-        __wbg___wbindgen_is_string_c4f7cb494a2a21f1: function(arg0) {
+        __wbg___wbindgen_is_string_90b56bc79aad6f6c: function(arg0) {
             const ret = typeof(arg0) === 'string';
             return ret;
         },
-        __wbg___wbindgen_is_undefined_8c687d0b90d5b524: function(arg0) {
+        __wbg___wbindgen_is_undefined_8865fb403f8fe9d8: function(arg0) {
             const ret = arg0 === undefined;
             return ret;
         },
-        __wbg___wbindgen_jsval_eq_9fdcd3c0a860dd3b: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_eq_02babf21faa37971: function(arg0, arg1) {
             const ret = arg0 === arg1;
             return ret;
         },
-        __wbg___wbindgen_jsval_loose_eq_3c30021c243b64cd: function(arg0, arg1) {
+        __wbg___wbindgen_jsval_loose_eq_677f21e468d6b461: function(arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
         },
-        __wbg___wbindgen_number_get_1dc732b810cb937c: function(arg0, arg1) {
+        __wbg___wbindgen_number_get_2e0e7dee9f701a71: function(arg0, arg1) {
             const obj = 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_string_get_92ab86bb19cbc12f: function(arg0, arg1) {
+        __wbg___wbindgen_string_get_0380ccaa2f57f0d9: function(arg0, arg1) {
             const obj = arg1;
             const ret = typeof(obj) === 'string' ? obj : undefined;
             var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
@@ -13030,67 +13083,67 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
+        __wbg___wbindgen_throw_41e9ee4f547fc59a: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
-        __wbg__wbg_cb_unref_997e73d32238e655: function(arg0) {
+        __wbg__wbg_cb_unref_dcc1a90847f04c41: function(arg0) {
             arg0._wbg_cb_unref();
         },
-        __wbg_abort_03f8c5804715cb9a: function(arg0, arg1) {
+        __wbg_abort_334e7f918b7c5047: function(arg0, arg1) {
             arg0.abort(arg1);
         },
-        __wbg_abort_76dea11221098ae5: function(arg0) {
+        __wbg_abort_f78b99d80248bacb: function(arg0) {
             arg0.abort();
         },
-        __wbg_append_66f1ae7ff7ad65c3: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
-            arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
-        }, arguments); },
-        __wbg_append_8e87c13f0f08f8cd: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+        __wbg_append_1938ed58fb5613b8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
             arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
         }, arguments); },
-        __wbg_append_df9039bc9160a880: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+        __wbg_append_627a9b311ac9993b: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             arg0.append(getStringFromWasm0(arg1, arg2), arg3);
         }, arguments); },
-        __wbg_append_e6bfd64552783e08: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_append_9b7024062a618f5d: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+            arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+        }, arguments); },
+        __wbg_append_cfa1814e91387699: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             arg0.append(getStringFromWasm0(arg1, arg2), arg3, getStringFromWasm0(arg4, arg5));
         }, arguments); },
-        __wbg_arrayBuffer_06f3da76f071d37f: function() { return handleError(function (arg0) {
+        __wbg_arrayBuffer_f07be74819944ea2: function() { return handleError(function (arg0) {
             const ret = arg0.arrayBuffer();
             return ret;
         }, arguments); },
-        __wbg_body_9ee03724e9ad0639: function(arg0) {
+        __wbg_body_4e088733babc630d: function(arg0) {
             const ret = arg0.body;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_buffer_4a989bded7035f57: function(arg0) {
+        __wbg_buffer_56ec2905a66f58b9: function(arg0) {
             const ret = arg0.buffer;
             return ret;
         },
-        __wbg_byobRequest_f161fc37241dd3d4: function(arg0) {
+        __wbg_byobRequest_54f7ce41d584549a: function(arg0) {
             const ret = arg0.byobRequest;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_byteLength_0ddb1795e2c7e689: function(arg0) {
+        __wbg_byteLength_9f985b8373f1f3fe: function(arg0) {
             const ret = arg0.byteLength;
             return ret;
         },
-        __wbg_byteOffset_46eb015f52b6ad7d: function(arg0) {
+        __wbg_byteOffset_0bd5a6a03553639c: function(arg0) {
             const ret = arg0.byteOffset;
             return ret;
         },
-        __wbg_call_269c5566fbede3eb: function() { return handleError(function (arg0, arg1) {
-            const ret = arg0.call(arg1);
+        __wbg_call_187d372bd5fdd4aa: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, arg2);
             return ret;
         }, arguments); },
-        __wbg_call_6bcf8d3e20937e46: function() { return handleError(function (arg0, arg1, arg2) {
-            const ret = arg0.call(arg1, arg2);
+        __wbg_call_6137034ef55c9d0f: function() { return handleError(function (arg0, arg1) {
+            const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_cancel_c076350a7e8954be: function(arg0) {
+        __wbg_cancel_7c2a08c8db4c73f3: function(arg0) {
             const ret = arg0.cancel();
             return ret;
         },
-        __wbg_catch_e2134ef6dcdb69ed: function(arg0, arg1) {
+        __wbg_catch_92594c2d17f55f12: function(arg0, arg1) {
             const ret = arg0.catch(arg1);
             return ret;
         },
@@ -13106,32 +13159,32 @@ function __wbg_get_imports() {
             const ret = clearTimeout(arg0);
             return ret;
         },
-        __wbg_close_22882088c136df25: function() { return handleError(function (arg0) {
+        __wbg_close_185286988f30f252: function() { return handleError(function (arg0) {
             arg0.close();
         }, arguments); },
-        __wbg_close_8b609460dd26e367: function() { return handleError(function (arg0) {
+        __wbg_close_748f26698dabe269: function() { return handleError(function (arg0) {
             arg0.close();
         }, arguments); },
-        __wbg_done_cffed884d87aa22e: function(arg0) {
+        __wbg_done_b41a1d26cdb37fb6: function(arg0) {
             const ret = arg0.done;
             return ret;
         },
-        __wbg_enqueue_6cb545d22db14f33: function() { return handleError(function (arg0, arg1) {
+        __wbg_enqueue_4a01c128f9a0de16: function() { return handleError(function (arg0, arg1) {
             arg0.enqueue(arg1);
         }, arguments); },
-        __wbg_entries_972a87586902cf87: function(arg0) {
-            const ret = Object.entries(arg0);
+        __wbg_entries_b55ec7e0dc443355: function(arg0) {
+            const ret = arg0.entries();
             return ret;
         },
-        __wbg_entries_f9de04c09a57314e: function(arg0) {
-            const ret = arg0.entries();
+        __wbg_entries_fb6397112b1de25f: function(arg0) {
+            const ret = Object.entries(arg0);
             return ret;
         },
         __wbg_fetch_7a37768ab67c5bd8: function(arg0) {
             const ret = fetch(arg0);
             return ret;
         },
-        __wbg_fetch_920242d59bac2026: function(arg0, arg1) {
+        __wbg_fetch_efc64baf325b084d: function(arg0, arg1) {
             const ret = arg0.fetch(arg1);
             return ret;
         },
@@ -13139,35 +13192,35 @@ function __wbg_get_imports() {
             const ret = arg0.getReader();
             return ret;
         }, arguments); },
-        __wbg_get_6cf5a4d4d8ad3c5a: function() { return handleError(function (arg0, arg1) {
+        __wbg_get_658f6698067d9515: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.get(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_get_b1f0ab13c737f856: function(arg0, arg1) {
+        __wbg_get_6c896e0571ddae51: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_get_done_a668aa62d81fad70: function(arg0) {
+        __wbg_get_done_7020b91c987365c7: function(arg0) {
             const ret = arg0.done;
             return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
         },
-        __wbg_get_unchecked_363572bdd397d473: function(arg0, arg1) {
+        __wbg_get_unchecked_288889d017702237: function(arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
         },
-        __wbg_get_value_6c62a77c168d825a: function(arg0) {
+        __wbg_get_value_87fbd6ad1283f2e7: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_has_464f8b9416279d65: function() { return handleError(function (arg0, arg1) {
+        __wbg_has_5d6706e5209576c1: function() { return handleError(function (arg0, arg1) {
             const ret = Reflect.has(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_headers_2594464ff62969f3: function(arg0) {
+        __wbg_headers_eba93595f8944c2f: function(arg0) {
             const ret = arg0.headers;
             return ret;
         },
-        __wbg_instanceof_ArrayBuffer_d4ff01f8247925ae: function(arg0) {
+        __wbg_instanceof_ArrayBuffer_a99f175873e5d9b8: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof ArrayBuffer;
@@ -13177,7 +13230,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Map_1ff6a2b54c899f0d: function(arg0) {
+        __wbg_instanceof_Map_b2611749102d7ba3: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Map;
@@ -13187,7 +13240,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Response_6366a785e400039b: function(arg0) {
+        __wbg_instanceof_Response_b8758567269c30b2: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Response;
@@ -13197,7 +13250,7 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_instanceof_Uint8Array_598adc0fef426aa8: function(arg0) {
+        __wbg_instanceof_Uint8Array_828cef2aaacafc31: function(arg0) {
             let result;
             try {
                 result = arg0 instanceof Uint8Array;
@@ -13207,70 +13260,70 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
-        __wbg_isArray_5674713bb7b79043: function(arg0) {
+        __wbg_isArray_e15a2ff68ffdbef2: function(arg0) {
             const ret = Array.isArray(arg0);
             return ret;
         },
-        __wbg_isSafeInteger_8f51c743827d1ec5: function(arg0) {
+        __wbg_isSafeInteger_717808ad6a54bd9e: function(arg0) {
             const ret = Number.isSafeInteger(arg0);
             return ret;
         },
-        __wbg_iterator_22ddeb808cf55a6f: function() {
+        __wbg_iterator_e3c31c892080e444: function() {
             const ret = Symbol.iterator;
             return ret;
         },
-        __wbg_length_31bdaf014f5fbde2: function(arg0) {
+        __wbg_length_7f3c00c40364105e: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_length_4e1adc0d42e23620: function(arg0) {
+        __wbg_length_d4bdea10311bd9cf: function(arg0) {
             const ret = arg0.length;
             return ret;
         },
-        __wbg_new_0afe64b4dc16ab74: function() { return handleError(function () {
-            const ret = new Headers();
-            return ret;
-        }, arguments); },
-        __wbg_new_1da3429bc3c4541c: function(arg0) {
+        __wbg_new_1dbf7428bba60a42: function(arg0) {
             const ret = new Uint8Array(arg0);
             return ret;
         },
-        __wbg_new_44f0ed775ff3a5ad: function() { return handleError(function () {
-            const ret = new FormData();
-            return ret;
-        }, arguments); },
-        __wbg_new_8d36e20aa758e411: function() {
+        __wbg_new_28744009d011f847: function() {
             const ret = new Map();
             return ret;
         },
-        __wbg_new_a32a1ab6c6655abe: function(arg0, arg1) {
-            const ret = new Error(getStringFromWasm0(arg0, arg1));
-            return ret;
-        },
-        __wbg_new_baa0a0207935dd43: function() { return handleError(function () {
+        __wbg_new_2e41357094e99294: function() { return handleError(function () {
             const ret = new AbortController();
             return ret;
         }, arguments); },
-        __wbg_new_bebc3f4757acf305: function() {
+        __wbg_new_343a093a3c2ffb4e: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return ret;
+        },
+        __wbg_new_617a8cdb8bb1130e: function() {
             const ret = new Object();
             return ret;
         },
-        __wbg_new_ffa92086ea89f79c: function() {
+        __wbg_new_83ca405eae412a62: function() { return handleError(function () {
+            const ret = new Headers();
+            return ret;
+        }, arguments); },
+        __wbg_new_d429ac7f5b1a2c5c: function() { return handleError(function () {
+            const ret = new FormData();
+            return ret;
+        }, arguments); },
+        __wbg_new_ee2291f50781bf1d: function() {
             const ret = new Array();
             return ret;
         },
-        __wbg_new_from_slice_4ee02165f9de919e: function(arg0, arg1) {
+        __wbg_new_from_slice_9a868026ffa4208a: function(arg0, arg1) {
             const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
             return ret;
         },
-        __wbg_new_typed_6f8b0d724fe26c07: function(arg0, arg1) {
+        __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__convert__closures_____invoke__h587dbcc500240430(a, state0.b, arg0, arg1);
+                        return wasm_bindgen__convert__closures_____invoke__h14136a31f7a759a2(a, state0.b, arg0, arg1);
                     } finally {
                         state0.a = a;
                     }
@@ -13281,23 +13334,23 @@ function __wbg_get_imports() {
                 state0.a = 0;
             }
         },
-        __wbg_new_with_byte_offset_and_length_492c969e8b5da8a4: function(arg0, arg1, arg2) {
+        __wbg_new_with_byte_offset_and_length_2f5d7fc2a828b74d: function(arg0, arg1, arg2) {
             const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
-        __wbg_new_with_str_and_init_2f31a77deda127fd: function() { return handleError(function (arg0, arg1, arg2) {
+        __wbg_new_with_str_and_init_4618dee4e950224f: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
             return ret;
         }, arguments); },
-        __wbg_new_with_u8_array_sequence_and_options_19dab14721682b5e: function() { return handleError(function (arg0, arg1) {
+        __wbg_new_with_u8_array_sequence_and_options_fccc08fe93f4b8fd: function() { return handleError(function (arg0, arg1) {
             const ret = new Blob(arg0, arg1);
             return ret;
         }, arguments); },
-        __wbg_next_95053e306b1c3aed: function(arg0) {
+        __wbg_next_33784799010f1bbe: function(arg0) {
             const ret = arg0.next;
             return ret;
         },
-        __wbg_next_f31ecb8646d2c605: function() { return handleError(function (arg0) {
+        __wbg_next_f4aac29c42af995c: function() { return handleError(function (arg0) {
             const ret = arg0.next();
             return ret;
         }, arguments); },
@@ -13305,7 +13358,7 @@ function __wbg_get_imports() {
             const ret = arg0.now();
             return ret;
         },
-        __wbg_parse_6937a9050adfb0e1: function() { return handleError(function (arg0, arg1) {
+        __wbg_parse_0fc53dead14b3b42: function() { return handleError(function (arg0, arg1) {
             const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
             return ret;
         }, arguments); },
@@ -13313,32 +13366,32 @@ function __wbg_get_imports() {
             const ret = arg0.performance;
             return ret;
         },
-        __wbg_prototypesetcall_ae9f5e7459250748: function(arg0, arg1, arg2) {
+        __wbg_prototypesetcall_bc27214492979395: function(arg0, arg1, arg2) {
             Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
         },
-        __wbg_push_bfdf956ba476f65b: function(arg0, arg1) {
+        __wbg_push_2baf45db356cf468: function(arg0, arg1) {
             const ret = arg0.push(arg1);
             return ret;
         },
-        __wbg_queueMicrotask_85c90f6987555d65: function(arg0) {
+        __wbg_queueMicrotask_9833f9a49df95a49: function(arg0) {
             const ret = arg0.queueMicrotask;
             return ret;
         },
-        __wbg_queueMicrotask_f6a1fa10b81d1fc0: function(arg0) {
+        __wbg_queueMicrotask_a72f977e97f23c5f: function(arg0) {
             queueMicrotask(arg0);
         },
-        __wbg_read_31091533ffadf971: function(arg0) {
+        __wbg_read_2a943774344c9728: function(arg0) {
             const ret = arg0.read();
             return ret;
         },
-        __wbg_releaseLock_1538945f5f183d9f: function(arg0) {
+        __wbg_releaseLock_eb64cd83aa9fcfe4: function(arg0) {
             arg0.releaseLock();
         },
-        __wbg_resolve_35ec7e0c6af4c82c: function(arg0) {
+        __wbg_resolve_0076e10020304ede: function(arg0) {
             const ret = Promise.resolve(arg0);
             return ret;
         },
-        __wbg_respond_83a71686e927ca32: function() { return handleError(function (arg0, arg1) {
+        __wbg_respond_c102fabcc79e5ef0: function() { return handleError(function (arg0, arg1) {
             arg0.respond(arg1 >>> 0);
         }, arguments); },
         __wbg_setTimeout_56bcdccbad22fd44: function() { return handleError(function (arg0, arg1) {
@@ -13349,97 +13402,97 @@ function __wbg_get_imports() {
             const ret = setTimeout(arg0, arg1);
             return ret;
         },
-        __wbg_set_13d25b81ab403f5e: function(arg0, arg1, arg2) {
-            arg0[arg1 >>> 0] = arg2;
-        },
-        __wbg_set_5f2ad37e5e02dc7b: function(arg0, arg1, arg2) {
+        __wbg_set_575d3ddb70fe831d: function(arg0, arg1, arg2) {
             arg0.set(getArrayU8FromWasm0(arg1, arg2));
         },
+        __wbg_set_6ae97e73113c4f0b: function(arg0, arg1, arg2) {
+            const ret = arg0.set(arg1, arg2);
+            return ret;
+        },
         __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
             arg0[arg1] = arg2;
         },
-        __wbg_set_bf6dde4923b9b059: function(arg0, arg1, arg2) {
-            const ret = arg0.set(arg1, arg2);
-            return ret;
+        __wbg_set_bea140a88be9b277: function(arg0, arg1, arg2) {
+            arg0[arg1 >>> 0] = arg2;
         },
-        __wbg_set_body_f39cee72c74a5b02: function(arg0, arg1) {
+        __wbg_set_body_1fb0f1008bfc7df6: function(arg0, arg1) {
             arg0.body = arg1;
         },
-        __wbg_set_cache_6e8c35a5ed76edb1: function(arg0, arg1) {
+        __wbg_set_cache_7507c4cc5938ccc7: function(arg0, arg1) {
             arg0.cache = __wbindgen_enum_RequestCache[arg1];
         },
-        __wbg_set_credentials_bf1d3e014213a571: function(arg0, arg1) {
+        __wbg_set_credentials_e0dcce31ca532b7d: function(arg0, arg1) {
             arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
         },
-        __wbg_set_headers_31d373f68f28bf76: function(arg0, arg1) {
+        __wbg_set_headers_40ad33dcf016613f: function(arg0, arg1) {
             arg0.headers = arg1;
         },
-        __wbg_set_method_82e6c3c083da0734: function(arg0, arg1, arg2) {
+        __wbg_set_method_dcb32343247ec427: function(arg0, arg1, arg2) {
             arg0.method = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_mode_f7e56ed768d0ade0: function(arg0, arg1) {
+        __wbg_set_mode_74e772635acb96ec: function(arg0, arg1) {
             arg0.mode = __wbindgen_enum_RequestMode[arg1];
         },
-        __wbg_set_referrer_13cf56bbccbb2ceb: function(arg0, arg1, arg2) {
+        __wbg_set_referrer_efd0fb956d6b70b2: function(arg0, arg1, arg2) {
             arg0.referrer = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_set_referrer_policy_dac1caa6e937479a: function(arg0, arg1) {
+        __wbg_set_referrer_policy_465382f52c1a03d3: function(arg0, arg1) {
             arg0.referrerPolicy = __wbindgen_enum_ReferrerPolicy[arg1];
         },
-        __wbg_set_signal_f4b32f40f19786f4: function(arg0, arg1) {
+        __wbg_set_signal_2dbd377604627f26: function(arg0, arg1) {
             arg0.signal = arg1;
         },
-        __wbg_set_type_69954a3c7c11a724: function(arg0, arg1, arg2) {
+        __wbg_set_type_dcf75b2afa60c694: function(arg0, arg1, arg2) {
             arg0.type = getStringFromWasm0(arg1, arg2);
         },
-        __wbg_signal_45367c6c2255877a: function(arg0) {
+        __wbg_signal_e5a49a2d9c65b7f6: function(arg0) {
             const ret = arg0.signal;
             return ret;
         },
-        __wbg_static_accessor_GLOBAL_8eb4cd83130a11a0: function() {
+        __wbg_static_accessor_GLOBAL_266715b9d96ba635: function() {
             const ret = typeof global === 'undefined' ? null : global;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_GLOBAL_THIS_1e7044f654e934db: function() {
+        __wbg_static_accessor_GLOBAL_THIS_10fb7dc1ae063179: function() {
             const ret = typeof globalThis === 'undefined' ? null : globalThis;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_SELF_d8b50611246a6d92: function() {
+        __wbg_static_accessor_SELF_0b583911f537483a: function() {
             const ret = typeof self === 'undefined' ? null : self;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_static_accessor_WINDOW_fd0bc376bf0f8b42: function() {
+        __wbg_static_accessor_WINDOW_d7f903d1508cbdc4: function() {
             const ret = typeof window === 'undefined' ? null : window;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
-        __wbg_status_88ccc72fe7bea621: function(arg0) {
+        __wbg_status_ce0a98d3c57125f3: function(arg0) {
             const ret = arg0.status;
             return ret;
         },
-        __wbg_text_b00323a194b10fa8: function() { return handleError(function (arg0) {
+        __wbg_text_ff3f476b3d6b1246: function() { return handleError(function (arg0) {
             const ret = arg0.text();
             return ret;
         }, arguments); },
-        __wbg_then_7a850dae4493f353: function(arg0, arg1, arg2) {
+        __wbg_then_c949d5a25a4e78f8: function(arg0, arg1, arg2) {
             const ret = arg0.then(arg1, arg2);
             return ret;
         },
-        __wbg_then_b830475380919203: function(arg0, arg1) {
+        __wbg_then_e71170d78fcf8954: function(arg0, arg1) {
             const ret = arg0.then(arg1);
             return ret;
         },
-        __wbg_url_f1948b0d7f881e02: function(arg0, arg1) {
+        __wbg_url_8e28edeab4cd6bed: function(arg0, arg1) {
             const ret = arg1.url;
             const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
             const len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_value_c227f843d21da141: function(arg0) {
+        __wbg_value_f3c585ee8f5ba40c: function(arg0) {
             const ret = arg0.value;
             return ret;
         },
-        __wbg_view_d8c7b26e4d4650f1: function(arg0) {
+        __wbg_view_9c570f33e8d6ab96: function(arg0) {
             const ret = arg0.view;
             return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
         },
@@ -13672,23 +13725,23 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_generic_0000000000000001: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 923, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hdbfd17fbffcf2c62);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 953, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h8663a1be0a3e38b0);
             return ret;
         },
         __wbindgen_generic_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 938, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h02a7923578afc9b7);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 971, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h49dc34f70620523b);
             return ret;
         },
         __wbindgen_generic_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 838, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h53a93f9ee7253a16);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 868, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h28ae67068accb1e8);
             return ret;
         },
         __wbindgen_generic_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 871, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
-            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h2b32076d58b95548);
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 901, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hacdd4ed9b378e86e);
             return ret;
         },
         __wbindgen_generic_0000000000000005: function(arg0) {
@@ -13734,27 +13787,27 @@ function __wbg_get_imports() {
     };
 }
 
-function wasm_bindgen__convert__closures_____invoke__h53a93f9ee7253a16(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h53a93f9ee7253a16(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h28ae67068accb1e8(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h28ae67068accb1e8(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h2b32076d58b95548(arg0, arg1) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h2b32076d58b95548(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__hacdd4ed9b378e86e(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hacdd4ed9b378e86e(arg0, arg1);
 }
 
-function wasm_bindgen__convert__closures_____invoke__hdbfd17fbffcf2c62(arg0, arg1, arg2) {
-    wasm.wasm_bindgen__convert__closures_____invoke__hdbfd17fbffcf2c62(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h8663a1be0a3e38b0(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h8663a1be0a3e38b0(arg0, arg1, arg2);
 }
 
-function wasm_bindgen__convert__closures_____invoke__h02a7923578afc9b7(arg0, arg1, arg2) {
-    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h02a7923578afc9b7(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h49dc34f70620523b(arg0, arg1, arg2) {
+    const ret = wasm.wasm_bindgen__convert__closures_____invoke__h49dc34f70620523b(arg0, arg1, arg2);
     if (ret[1]) {
         throw takeFromExternrefTable0(ret[0]);
     }
 }
 
-function wasm_bindgen__convert__closures_____invoke__h587dbcc500240430(arg0, arg1, arg2, arg3) {
-    wasm.wasm_bindgen__convert__closures_____invoke__h587dbcc500240430(arg0, arg1, arg2, arg3);
+function wasm_bindgen__convert__closures_____invoke__h14136a31f7a759a2(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h14136a31f7a759a2(arg0, arg1, arg2, arg3);
 }