libfw-client 0.4.7 → 0.4.8
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +3 -2
- package/pkg/libfw_client.d.ts +142 -0
- package/pkg/libfw_client.js +1005 -0
- package/pkg/libfw_client_bg.wasm +0 -0
- package/pkg/libfw_client_bg.wasm.d.ts +35 -0
- package/pkg/package.json +28 -0
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "libfw-client",
|
|
3
|
-
"version": "0.4.
|
|
3
|
+
"version": "0.4.8",
|
|
4
4
|
"description": "libfw client for browsers, providing high performance file transfer capabilities using WebAssembly.",
|
|
5
5
|
"license": "MIT",
|
|
6
6
|
"repository": {
|
|
@@ -35,7 +35,8 @@
|
|
|
35
35
|
],
|
|
36
36
|
"sideEffects": false,
|
|
37
37
|
"scripts": {
|
|
38
|
-
"
|
|
38
|
+
"prepublishOnly": "node scripts/verify-pkg.cjs",
|
|
39
|
+
"build:wasm": "wasm-pack build ../crates/libfw-client --target web --out-dir ../../sdk/pkg --release && rm -f pkg/.gitignore",
|
|
39
40
|
"build:umd": "rollup -c rollup.config.mjs",
|
|
40
41
|
"build": "npm run build:wasm && npm run build:umd"
|
|
41
42
|
},
|
|
@@ -0,0 +1,142 @@
|
|
|
1
|
+
/* tslint:disable */
|
|
2
|
+
/* eslint-disable */
|
|
3
|
+
|
|
4
|
+
/**
|
|
5
|
+
* WASM engine facade. Construct via `new LibfwClient(options)`.
|
|
6
|
+
*/
|
|
7
|
+
export class LibfwClient {
|
|
8
|
+
free(): void;
|
|
9
|
+
[Symbol.dispose](): void;
|
|
10
|
+
/**
|
|
11
|
+
* Cancel the active transfer (state → `failed`).
|
|
12
|
+
*/
|
|
13
|
+
cancel(): void;
|
|
14
|
+
/**
|
|
15
|
+
* Bytes transferred so far.
|
|
16
|
+
*/
|
|
17
|
+
done_bytes(): number;
|
|
18
|
+
/**
|
|
19
|
+
* Download a single file at `file_path` into the chosen local directory.
|
|
20
|
+
*/
|
|
21
|
+
download_file(base_url: string, token: string, file_path: string): Promise<any>;
|
|
22
|
+
/**
|
|
23
|
+
* Download every file under the virtual `dirPath` (empty = root).
|
|
24
|
+
*/
|
|
25
|
+
download_folder(base_url: string, token: string, dir_path: string): Promise<any>;
|
|
26
|
+
/**
|
|
27
|
+
* Whether callbacks have been installed.
|
|
28
|
+
*/
|
|
29
|
+
has_callbacks(): boolean;
|
|
30
|
+
/**
|
|
31
|
+
* Create an engine. `options` may include:
|
|
32
|
+
* `{ concurrency, uploadWindow, downloadWindow, compress,
|
|
33
|
+
* compressLevel, chunkSize, maxRetries, baseRetryDelayMs,
|
|
34
|
+
* maxRetryDelayMs, timeoutMs, autoTune, tuneTtlMs }`.
|
|
35
|
+
*/
|
|
36
|
+
constructor(opts: any);
|
|
37
|
+
/**
|
|
38
|
+
* Pause the active transfer (state → `paused`).
|
|
39
|
+
*/
|
|
40
|
+
pause(): void;
|
|
41
|
+
/**
|
|
42
|
+
* Progress in `[0, 1]`.
|
|
43
|
+
*/
|
|
44
|
+
progress(): number;
|
|
45
|
+
/**
|
|
46
|
+
* Resume a paused transfer.
|
|
47
|
+
*/
|
|
48
|
+
resume(): void;
|
|
49
|
+
/**
|
|
50
|
+
* Install the JS callbacks object (required before any transfer).
|
|
51
|
+
*/
|
|
52
|
+
set_callbacks(callbacks: any): void;
|
|
53
|
+
/**
|
|
54
|
+
* Install an `onTuning(phase, params, stats)` callback, invoked on
|
|
55
|
+
* every tuning state change (phase transitions and window evaluations).
|
|
56
|
+
*/
|
|
57
|
+
set_tune_callback(cb: any): void;
|
|
58
|
+
/**
|
|
59
|
+
* Current state: `idle | downloading | uploading | paused | completed |
|
|
60
|
+
* failed`.
|
|
61
|
+
*/
|
|
62
|
+
state(): string;
|
|
63
|
+
/**
|
|
64
|
+
* Total bytes to transfer.
|
|
65
|
+
*/
|
|
66
|
+
total_bytes(): number;
|
|
67
|
+
/**
|
|
68
|
+
* Snapshot the tuning engine: `{ phase, params, stats, capsHash }`.
|
|
69
|
+
*/
|
|
70
|
+
tune_state(): any;
|
|
71
|
+
/**
|
|
72
|
+
* Upload the files reported by the JS `getFileList` callback.
|
|
73
|
+
*/
|
|
74
|
+
upload(base_url: string, token: string): Promise<any>;
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
/**
|
|
78
|
+
* Read an optional string field from a JS object (helper for the SDK).
|
|
79
|
+
*/
|
|
80
|
+
export function js_option_string(obj: any, key: string): string | undefined;
|
|
81
|
+
|
|
82
|
+
export function start(): void;
|
|
83
|
+
|
|
84
|
+
export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
|
|
85
|
+
|
|
86
|
+
export interface InitOutput {
|
|
87
|
+
readonly memory: WebAssembly.Memory;
|
|
88
|
+
readonly __wbg_libfwclient_free: (a: number, b: number) => void;
|
|
89
|
+
readonly js_option_string: (a: any, b: number, c: number) => [number, number];
|
|
90
|
+
readonly libfwclient_cancel: (a: number) => void;
|
|
91
|
+
readonly libfwclient_done_bytes: (a: number) => number;
|
|
92
|
+
readonly libfwclient_download_file: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
|
|
93
|
+
readonly libfwclient_download_folder: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
|
|
94
|
+
readonly libfwclient_has_callbacks: (a: number) => number;
|
|
95
|
+
readonly libfwclient_new: (a: any) => number;
|
|
96
|
+
readonly libfwclient_pause: (a: number) => void;
|
|
97
|
+
readonly libfwclient_progress: (a: number) => number;
|
|
98
|
+
readonly libfwclient_resume: (a: number) => void;
|
|
99
|
+
readonly libfwclient_set_callbacks: (a: number, b: any) => void;
|
|
100
|
+
readonly libfwclient_set_tune_callback: (a: number, b: any) => void;
|
|
101
|
+
readonly libfwclient_state: (a: number) => [number, number];
|
|
102
|
+
readonly libfwclient_total_bytes: (a: number) => number;
|
|
103
|
+
readonly libfwclient_tune_state: (a: number) => any;
|
|
104
|
+
readonly libfwclient_upload: (a: number, b: number, c: number, d: number, e: number) => any;
|
|
105
|
+
readonly start: () => void;
|
|
106
|
+
readonly wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue__core_d941ad8722425d2e___result__Result_____wasm_bindgen_61f1d8f55010c370___JsError___true_: (a: number, b: number, c: any) => [number, number];
|
|
107
|
+
readonly wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
|
|
108
|
+
readonly wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true_: (a: number, b: number, c: any) => void;
|
|
109
|
+
readonly wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true__2: (a: number, b: number, c: any) => void;
|
|
110
|
+
readonly wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke_______true_: (a: number, b: number) => void;
|
|
111
|
+
readonly __wbindgen_malloc: (a: number, b: number) => number;
|
|
112
|
+
readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
|
|
113
|
+
readonly __wbindgen_exn_store: (a: number) => void;
|
|
114
|
+
readonly __externref_table_alloc: () => number;
|
|
115
|
+
readonly __wbindgen_externrefs: WebAssembly.Table;
|
|
116
|
+
readonly __wbindgen_free: (a: number, b: number, c: number) => void;
|
|
117
|
+
readonly __wbindgen_destroy_closure: (a: number, b: number) => void;
|
|
118
|
+
readonly __externref_table_dealloc: (a: number) => void;
|
|
119
|
+
readonly __wbindgen_start: () => void;
|
|
120
|
+
}
|
|
121
|
+
|
|
122
|
+
export type SyncInitInput = BufferSource | WebAssembly.Module;
|
|
123
|
+
|
|
124
|
+
/**
|
|
125
|
+
* Instantiates the given `module`, which can either be bytes or
|
|
126
|
+
* a precompiled `WebAssembly.Module`.
|
|
127
|
+
*
|
|
128
|
+
* @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
|
|
129
|
+
*
|
|
130
|
+
* @returns {InitOutput}
|
|
131
|
+
*/
|
|
132
|
+
export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
|
|
133
|
+
|
|
134
|
+
/**
|
|
135
|
+
* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
|
|
136
|
+
* for everything else, calls `WebAssembly.instantiate` directly.
|
|
137
|
+
*
|
|
138
|
+
* @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
|
|
139
|
+
*
|
|
140
|
+
* @returns {Promise<InitOutput>}
|
|
141
|
+
*/
|
|
142
|
+
export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;
|
|
@@ -0,0 +1,1005 @@
|
|
|
1
|
+
/* @ts-self-types="./libfw_client.d.ts" */
|
|
2
|
+
|
|
3
|
+
/**
|
|
4
|
+
* WASM engine facade. Construct via `new LibfwClient(options)`.
|
|
5
|
+
*/
|
|
6
|
+
export class LibfwClient {
|
|
7
|
+
__destroy_into_raw() {
|
|
8
|
+
const ptr = this.__wbg_ptr;
|
|
9
|
+
this.__wbg_ptr = 0;
|
|
10
|
+
LibfwClientFinalization.unregister(this);
|
|
11
|
+
return ptr;
|
|
12
|
+
}
|
|
13
|
+
free() {
|
|
14
|
+
const ptr = this.__destroy_into_raw();
|
|
15
|
+
wasm.__wbg_libfwclient_free(ptr, 0);
|
|
16
|
+
}
|
|
17
|
+
/**
|
|
18
|
+
* Cancel the active transfer (state → `failed`).
|
|
19
|
+
*/
|
|
20
|
+
cancel() {
|
|
21
|
+
wasm.libfwclient_cancel(this.__wbg_ptr);
|
|
22
|
+
}
|
|
23
|
+
/**
|
|
24
|
+
* Bytes transferred so far.
|
|
25
|
+
* @returns {number}
|
|
26
|
+
*/
|
|
27
|
+
done_bytes() {
|
|
28
|
+
const ret = wasm.libfwclient_done_bytes(this.__wbg_ptr);
|
|
29
|
+
return ret;
|
|
30
|
+
}
|
|
31
|
+
/**
|
|
32
|
+
* Download a single file at `file_path` into the chosen local directory.
|
|
33
|
+
* @param {string} base_url
|
|
34
|
+
* @param {string} token
|
|
35
|
+
* @param {string} file_path
|
|
36
|
+
* @returns {Promise<any>}
|
|
37
|
+
*/
|
|
38
|
+
download_file(base_url, token, file_path) {
|
|
39
|
+
const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
40
|
+
const len0 = WASM_VECTOR_LEN;
|
|
41
|
+
const ptr1 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
42
|
+
const len1 = WASM_VECTOR_LEN;
|
|
43
|
+
const ptr2 = passStringToWasm0(file_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
44
|
+
const len2 = WASM_VECTOR_LEN;
|
|
45
|
+
const ret = wasm.libfwclient_download_file(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
46
|
+
return ret;
|
|
47
|
+
}
|
|
48
|
+
/**
|
|
49
|
+
* Download every file under the virtual `dirPath` (empty = root).
|
|
50
|
+
* @param {string} base_url
|
|
51
|
+
* @param {string} token
|
|
52
|
+
* @param {string} dir_path
|
|
53
|
+
* @returns {Promise<any>}
|
|
54
|
+
*/
|
|
55
|
+
download_folder(base_url, token, dir_path) {
|
|
56
|
+
const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
57
|
+
const len0 = WASM_VECTOR_LEN;
|
|
58
|
+
const ptr1 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
59
|
+
const len1 = WASM_VECTOR_LEN;
|
|
60
|
+
const ptr2 = passStringToWasm0(dir_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
61
|
+
const len2 = WASM_VECTOR_LEN;
|
|
62
|
+
const ret = wasm.libfwclient_download_folder(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
|
|
63
|
+
return ret;
|
|
64
|
+
}
|
|
65
|
+
/**
|
|
66
|
+
* Whether callbacks have been installed.
|
|
67
|
+
* @returns {boolean}
|
|
68
|
+
*/
|
|
69
|
+
has_callbacks() {
|
|
70
|
+
const ret = wasm.libfwclient_has_callbacks(this.__wbg_ptr);
|
|
71
|
+
return ret !== 0;
|
|
72
|
+
}
|
|
73
|
+
/**
|
|
74
|
+
* Create an engine. `options` may include:
|
|
75
|
+
* `{ concurrency, uploadWindow, downloadWindow, compress,
|
|
76
|
+
* compressLevel, chunkSize, maxRetries, baseRetryDelayMs,
|
|
77
|
+
* maxRetryDelayMs, timeoutMs, autoTune, tuneTtlMs }`.
|
|
78
|
+
* @param {any} opts
|
|
79
|
+
*/
|
|
80
|
+
constructor(opts) {
|
|
81
|
+
const ret = wasm.libfwclient_new(opts);
|
|
82
|
+
this.__wbg_ptr = ret;
|
|
83
|
+
LibfwClientFinalization.register(this, this.__wbg_ptr, this);
|
|
84
|
+
return this;
|
|
85
|
+
}
|
|
86
|
+
/**
|
|
87
|
+
* Pause the active transfer (state → `paused`).
|
|
88
|
+
*/
|
|
89
|
+
pause() {
|
|
90
|
+
wasm.libfwclient_pause(this.__wbg_ptr);
|
|
91
|
+
}
|
|
92
|
+
/**
|
|
93
|
+
* Progress in `[0, 1]`.
|
|
94
|
+
* @returns {number}
|
|
95
|
+
*/
|
|
96
|
+
progress() {
|
|
97
|
+
const ret = wasm.libfwclient_progress(this.__wbg_ptr);
|
|
98
|
+
return ret;
|
|
99
|
+
}
|
|
100
|
+
/**
|
|
101
|
+
* Resume a paused transfer.
|
|
102
|
+
*/
|
|
103
|
+
resume() {
|
|
104
|
+
wasm.libfwclient_resume(this.__wbg_ptr);
|
|
105
|
+
}
|
|
106
|
+
/**
|
|
107
|
+
* Install the JS callbacks object (required before any transfer).
|
|
108
|
+
* @param {any} callbacks
|
|
109
|
+
*/
|
|
110
|
+
set_callbacks(callbacks) {
|
|
111
|
+
wasm.libfwclient_set_callbacks(this.__wbg_ptr, callbacks);
|
|
112
|
+
}
|
|
113
|
+
/**
|
|
114
|
+
* Install an `onTuning(phase, params, stats)` callback, invoked on
|
|
115
|
+
* every tuning state change (phase transitions and window evaluations).
|
|
116
|
+
* @param {any} cb
|
|
117
|
+
*/
|
|
118
|
+
set_tune_callback(cb) {
|
|
119
|
+
wasm.libfwclient_set_tune_callback(this.__wbg_ptr, cb);
|
|
120
|
+
}
|
|
121
|
+
/**
|
|
122
|
+
* Current state: `idle | downloading | uploading | paused | completed |
|
|
123
|
+
* failed`.
|
|
124
|
+
* @returns {string}
|
|
125
|
+
*/
|
|
126
|
+
state() {
|
|
127
|
+
let deferred1_0;
|
|
128
|
+
let deferred1_1;
|
|
129
|
+
try {
|
|
130
|
+
const ret = wasm.libfwclient_state(this.__wbg_ptr);
|
|
131
|
+
deferred1_0 = ret[0];
|
|
132
|
+
deferred1_1 = ret[1];
|
|
133
|
+
return getStringFromWasm0(ret[0], ret[1]);
|
|
134
|
+
} finally {
|
|
135
|
+
wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
|
|
136
|
+
}
|
|
137
|
+
}
|
|
138
|
+
/**
|
|
139
|
+
* Total bytes to transfer.
|
|
140
|
+
* @returns {number}
|
|
141
|
+
*/
|
|
142
|
+
total_bytes() {
|
|
143
|
+
const ret = wasm.libfwclient_total_bytes(this.__wbg_ptr);
|
|
144
|
+
return ret;
|
|
145
|
+
}
|
|
146
|
+
/**
|
|
147
|
+
* Snapshot the tuning engine: `{ phase, params, stats, capsHash }`.
|
|
148
|
+
* @returns {any}
|
|
149
|
+
*/
|
|
150
|
+
tune_state() {
|
|
151
|
+
const ret = wasm.libfwclient_tune_state(this.__wbg_ptr);
|
|
152
|
+
return ret;
|
|
153
|
+
}
|
|
154
|
+
/**
|
|
155
|
+
* Upload the files reported by the JS `getFileList` callback.
|
|
156
|
+
* @param {string} base_url
|
|
157
|
+
* @param {string} token
|
|
158
|
+
* @returns {Promise<any>}
|
|
159
|
+
*/
|
|
160
|
+
upload(base_url, token) {
|
|
161
|
+
const ptr0 = passStringToWasm0(base_url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
162
|
+
const len0 = WASM_VECTOR_LEN;
|
|
163
|
+
const ptr1 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
164
|
+
const len1 = WASM_VECTOR_LEN;
|
|
165
|
+
const ret = wasm.libfwclient_upload(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
166
|
+
return ret;
|
|
167
|
+
}
|
|
168
|
+
}
|
|
169
|
+
if (Symbol.dispose) LibfwClient.prototype[Symbol.dispose] = LibfwClient.prototype.free;
|
|
170
|
+
|
|
171
|
+
/**
|
|
172
|
+
* Read an optional string field from a JS object (helper for the SDK).
|
|
173
|
+
* @param {any} obj
|
|
174
|
+
* @param {string} key
|
|
175
|
+
* @returns {string | undefined}
|
|
176
|
+
*/
|
|
177
|
+
export function js_option_string(obj, key) {
|
|
178
|
+
const ptr0 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
179
|
+
const len0 = WASM_VECTOR_LEN;
|
|
180
|
+
const ret = wasm.js_option_string(obj, ptr0, len0);
|
|
181
|
+
let v2;
|
|
182
|
+
if (ret[0] !== 0) {
|
|
183
|
+
v2 = getStringFromWasm0(ret[0], ret[1]).slice();
|
|
184
|
+
wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
|
|
185
|
+
}
|
|
186
|
+
return v2;
|
|
187
|
+
}
|
|
188
|
+
|
|
189
|
+
export function start() {
|
|
190
|
+
wasm.start();
|
|
191
|
+
}
|
|
192
|
+
function __wbg_get_imports() {
|
|
193
|
+
const import0 = {
|
|
194
|
+
__proto__: null,
|
|
195
|
+
__wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function(arg0) {
|
|
196
|
+
const v = arg0;
|
|
197
|
+
const ret = typeof(v) === 'boolean' ? v : undefined;
|
|
198
|
+
return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
|
|
199
|
+
},
|
|
200
|
+
__wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
|
|
201
|
+
const ret = debugString(arg1);
|
|
202
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
203
|
+
const len1 = WASM_VECTOR_LEN;
|
|
204
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
205
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
206
|
+
},
|
|
207
|
+
__wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
|
|
208
|
+
const ret = typeof(arg0) === 'function';
|
|
209
|
+
return ret;
|
|
210
|
+
},
|
|
211
|
+
__wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
|
|
212
|
+
const ret = arg0 === null;
|
|
213
|
+
return ret;
|
|
214
|
+
},
|
|
215
|
+
__wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
|
|
216
|
+
const val = arg0;
|
|
217
|
+
const ret = typeof(val) === 'object' && val !== null;
|
|
218
|
+
return ret;
|
|
219
|
+
},
|
|
220
|
+
__wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
|
|
221
|
+
const ret = arg0 === undefined;
|
|
222
|
+
return ret;
|
|
223
|
+
},
|
|
224
|
+
__wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
|
|
225
|
+
const obj = arg1;
|
|
226
|
+
const ret = typeof(obj) === 'number' ? obj : undefined;
|
|
227
|
+
getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
|
|
228
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
|
|
229
|
+
},
|
|
230
|
+
__wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
|
|
231
|
+
const obj = arg1;
|
|
232
|
+
const ret = typeof(obj) === 'string' ? obj : undefined;
|
|
233
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
234
|
+
var len1 = WASM_VECTOR_LEN;
|
|
235
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
236
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
237
|
+
},
|
|
238
|
+
__wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
|
|
239
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
240
|
+
},
|
|
241
|
+
__wbg__wbg_cb_unref_fffb441def202758: function(arg0) {
|
|
242
|
+
arg0._wbg_cb_unref();
|
|
243
|
+
},
|
|
244
|
+
__wbg_abort_4426bc6bd4153680: function() { return handleError(function (arg0) {
|
|
245
|
+
arg0.abort();
|
|
246
|
+
}, arguments); },
|
|
247
|
+
__wbg_abort_8bae0f33e7833997: function(arg0) {
|
|
248
|
+
arg0.abort();
|
|
249
|
+
},
|
|
250
|
+
__wbg_apply_3ac86a26fdb56c05: function() { return handleError(function (arg0, arg1, arg2) {
|
|
251
|
+
const ret = arg0.apply(arg1, arg2);
|
|
252
|
+
return ret;
|
|
253
|
+
}, arguments); },
|
|
254
|
+
__wbg_arrayBuffer_3b637f0fa65c5351: function() { return handleError(function (arg0) {
|
|
255
|
+
const ret = arg0.arrayBuffer();
|
|
256
|
+
return ret;
|
|
257
|
+
}, arguments); },
|
|
258
|
+
__wbg_body_18c9f2ac15ead4b2: function(arg0) {
|
|
259
|
+
const ret = arg0.body;
|
|
260
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
261
|
+
},
|
|
262
|
+
__wbg_call_44b7209e1e252e6a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
263
|
+
const ret = arg0.call(arg1, arg2, arg3, arg4);
|
|
264
|
+
return ret;
|
|
265
|
+
}, arguments); },
|
|
266
|
+
__wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
|
|
267
|
+
const ret = arg0.call(arg1, arg2);
|
|
268
|
+
return ret;
|
|
269
|
+
}, arguments); },
|
|
270
|
+
__wbg_catch_c1a60df4c30d76d3: function(arg0, arg1) {
|
|
271
|
+
const ret = arg0.catch(arg1);
|
|
272
|
+
return ret;
|
|
273
|
+
},
|
|
274
|
+
__wbg_clearInterval_2e2069e95ad09d4f: function(arg0, arg1) {
|
|
275
|
+
arg0.clearInterval(arg1);
|
|
276
|
+
},
|
|
277
|
+
__wbg_clearTimeout_8f80437be2324e09: function(arg0, arg1) {
|
|
278
|
+
arg0.clearTimeout(arg1);
|
|
279
|
+
},
|
|
280
|
+
__wbg_encodeURIComponent_d0140ae6e13eb27b: function(arg0, arg1) {
|
|
281
|
+
const ret = encodeURIComponent(getStringFromWasm0(arg0, arg1));
|
|
282
|
+
return ret;
|
|
283
|
+
},
|
|
284
|
+
__wbg_error_a6fa202b58aa1cd3: function(arg0, arg1) {
|
|
285
|
+
let deferred0_0;
|
|
286
|
+
let deferred0_1;
|
|
287
|
+
try {
|
|
288
|
+
deferred0_0 = arg0;
|
|
289
|
+
deferred0_1 = arg1;
|
|
290
|
+
console.error(getStringFromWasm0(arg0, arg1));
|
|
291
|
+
} finally {
|
|
292
|
+
wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
|
|
293
|
+
}
|
|
294
|
+
},
|
|
295
|
+
__wbg_fetch_6ecc661950e58d49: function(arg0, arg1) {
|
|
296
|
+
const ret = arg0.fetch(arg1);
|
|
297
|
+
return ret;
|
|
298
|
+
},
|
|
299
|
+
__wbg_from_13e323c65fc8f464: function(arg0) {
|
|
300
|
+
const ret = Array.from(arg0);
|
|
301
|
+
return ret;
|
|
302
|
+
},
|
|
303
|
+
__wbg_getItem_b96269ddc16cf24a: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
304
|
+
const ret = arg1.getItem(getStringFromWasm0(arg2, arg3));
|
|
305
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
306
|
+
var len1 = WASM_VECTOR_LEN;
|
|
307
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
308
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
309
|
+
}, arguments); },
|
|
310
|
+
__wbg_getReader_7455d080fa48369b: function(arg0) {
|
|
311
|
+
const ret = arg0.getReader();
|
|
312
|
+
return ret;
|
|
313
|
+
},
|
|
314
|
+
__wbg_get_18e0163e38e5048d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
315
|
+
const ret = arg1.get(getStringFromWasm0(arg2, arg3));
|
|
316
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
317
|
+
var len1 = WASM_VECTOR_LEN;
|
|
318
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
319
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
320
|
+
}, arguments); },
|
|
321
|
+
__wbg_get_78f252d074a84d0b: function() { return handleError(function (arg0, arg1) {
|
|
322
|
+
const ret = Reflect.get(arg0, arg1);
|
|
323
|
+
return ret;
|
|
324
|
+
}, arguments); },
|
|
325
|
+
__wbg_get_unchecked_6e0ad6d2a41b06f6: function(arg0, arg1) {
|
|
326
|
+
const ret = arg0[arg1 >>> 0];
|
|
327
|
+
return ret;
|
|
328
|
+
},
|
|
329
|
+
__wbg_has_8374cf06984d8bfc: function() { return handleError(function (arg0, arg1) {
|
|
330
|
+
const ret = Reflect.has(arg0, arg1);
|
|
331
|
+
return ret;
|
|
332
|
+
}, arguments); },
|
|
333
|
+
__wbg_headers_cf9c80f30e2a4eff: function(arg0) {
|
|
334
|
+
const ret = arg0.headers;
|
|
335
|
+
return ret;
|
|
336
|
+
},
|
|
337
|
+
__wbg_instanceof_ArrayBuffer_4480b9e0068a8adb: function(arg0) {
|
|
338
|
+
let result;
|
|
339
|
+
try {
|
|
340
|
+
result = arg0 instanceof ArrayBuffer;
|
|
341
|
+
} catch (_) {
|
|
342
|
+
result = false;
|
|
343
|
+
}
|
|
344
|
+
const ret = result;
|
|
345
|
+
return ret;
|
|
346
|
+
},
|
|
347
|
+
__wbg_instanceof_Blob_c6523f92a32c8695: function(arg0) {
|
|
348
|
+
let result;
|
|
349
|
+
try {
|
|
350
|
+
result = arg0 instanceof Blob;
|
|
351
|
+
} catch (_) {
|
|
352
|
+
result = false;
|
|
353
|
+
}
|
|
354
|
+
const ret = result;
|
|
355
|
+
return ret;
|
|
356
|
+
},
|
|
357
|
+
__wbg_instanceof_Uint8Array_309b927aaf7a3fc7: function(arg0) {
|
|
358
|
+
let result;
|
|
359
|
+
try {
|
|
360
|
+
result = arg0 instanceof Uint8Array;
|
|
361
|
+
} catch (_) {
|
|
362
|
+
result = false;
|
|
363
|
+
}
|
|
364
|
+
const ret = result;
|
|
365
|
+
return ret;
|
|
366
|
+
},
|
|
367
|
+
__wbg_instanceof_Window_05ba1ee4f6781663: function(arg0) {
|
|
368
|
+
let result;
|
|
369
|
+
try {
|
|
370
|
+
result = arg0 instanceof Window;
|
|
371
|
+
} catch (_) {
|
|
372
|
+
result = false;
|
|
373
|
+
}
|
|
374
|
+
const ret = result;
|
|
375
|
+
return ret;
|
|
376
|
+
},
|
|
377
|
+
__wbg_length_1f0964f4a5e2c6d8: function(arg0) {
|
|
378
|
+
const ret = arg0.length;
|
|
379
|
+
return ret;
|
|
380
|
+
},
|
|
381
|
+
__wbg_length_370319915dc99107: function(arg0) {
|
|
382
|
+
const ret = arg0.length;
|
|
383
|
+
return ret;
|
|
384
|
+
},
|
|
385
|
+
__wbg_loaded_e4436631cb081781: function(arg0) {
|
|
386
|
+
const ret = arg0.loaded;
|
|
387
|
+
return ret;
|
|
388
|
+
},
|
|
389
|
+
__wbg_localStorage_5bf6ce3f8e51412a: function() { return handleError(function (arg0) {
|
|
390
|
+
const ret = arg0.localStorage;
|
|
391
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
392
|
+
}, arguments); },
|
|
393
|
+
__wbg_new_0d809930cd1354c6: function() { return handleError(function () {
|
|
394
|
+
const ret = new Headers();
|
|
395
|
+
return ret;
|
|
396
|
+
}, arguments); },
|
|
397
|
+
__wbg_new_227d7c05414eb861: function() {
|
|
398
|
+
const ret = new Error();
|
|
399
|
+
return ret;
|
|
400
|
+
},
|
|
401
|
+
__wbg_new_32b398fb48b6d94a: function() {
|
|
402
|
+
const ret = new Array();
|
|
403
|
+
return ret;
|
|
404
|
+
},
|
|
405
|
+
__wbg_new_4339b2a2675a03e3: function() { return handleError(function () {
|
|
406
|
+
const ret = new AbortController();
|
|
407
|
+
return ret;
|
|
408
|
+
}, arguments); },
|
|
409
|
+
__wbg_new_6b1dd7bed0e5462c: function() { return handleError(function () {
|
|
410
|
+
const ret = new XMLHttpRequest();
|
|
411
|
+
return ret;
|
|
412
|
+
}, arguments); },
|
|
413
|
+
__wbg_new_aec3e25493d729fe: function(arg0, arg1) {
|
|
414
|
+
try {
|
|
415
|
+
var state0 = {a: arg0, b: arg1};
|
|
416
|
+
var cb0 = (arg0, arg1) => {
|
|
417
|
+
const a = state0.a;
|
|
418
|
+
state0.a = 0;
|
|
419
|
+
try {
|
|
420
|
+
return wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined_______true_(a, state0.b, arg0, arg1);
|
|
421
|
+
} finally {
|
|
422
|
+
state0.a = a;
|
|
423
|
+
}
|
|
424
|
+
};
|
|
425
|
+
const ret = new Promise(cb0);
|
|
426
|
+
return ret;
|
|
427
|
+
} finally {
|
|
428
|
+
state0.a = 0;
|
|
429
|
+
}
|
|
430
|
+
},
|
|
431
|
+
__wbg_new_b667d279fd5aa943: function(arg0, arg1) {
|
|
432
|
+
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
433
|
+
return ret;
|
|
434
|
+
},
|
|
435
|
+
__wbg_new_cd45aabdf6073e84: function(arg0) {
|
|
436
|
+
const ret = new Uint8Array(arg0);
|
|
437
|
+
return ret;
|
|
438
|
+
},
|
|
439
|
+
__wbg_new_da52cf8fe3429cb2: function() {
|
|
440
|
+
const ret = new Object();
|
|
441
|
+
return ret;
|
|
442
|
+
},
|
|
443
|
+
__wbg_new_from_slice_77cdfb7977362f3c: function(arg0, arg1) {
|
|
444
|
+
const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
|
|
445
|
+
return ret;
|
|
446
|
+
},
|
|
447
|
+
__wbg_new_typed_1824d93f294193e5: function(arg0, arg1) {
|
|
448
|
+
try {
|
|
449
|
+
var state0 = {a: arg0, b: arg1};
|
|
450
|
+
var cb0 = (arg0, arg1) => {
|
|
451
|
+
const a = state0.a;
|
|
452
|
+
state0.a = 0;
|
|
453
|
+
try {
|
|
454
|
+
return wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined_______true_(a, state0.b, arg0, arg1);
|
|
455
|
+
} finally {
|
|
456
|
+
state0.a = a;
|
|
457
|
+
}
|
|
458
|
+
};
|
|
459
|
+
const ret = new Promise(cb0);
|
|
460
|
+
return ret;
|
|
461
|
+
} finally {
|
|
462
|
+
state0.a = 0;
|
|
463
|
+
}
|
|
464
|
+
},
|
|
465
|
+
__wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
|
|
466
|
+
const ret = new Uint8Array(arg0 >>> 0);
|
|
467
|
+
return ret;
|
|
468
|
+
},
|
|
469
|
+
__wbg_new_with_str_and_init_d95cbe11ce28e65e: function() { return handleError(function (arg0, arg1, arg2) {
|
|
470
|
+
const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
|
|
471
|
+
return ret;
|
|
472
|
+
}, arguments); },
|
|
473
|
+
__wbg_new_with_u8_array_sequence_bdda73b0f202f149: function() { return handleError(function (arg0) {
|
|
474
|
+
const ret = new Blob(arg0);
|
|
475
|
+
return ret;
|
|
476
|
+
}, arguments); },
|
|
477
|
+
__wbg_now_86c0d4ba3fa605b8: function() {
|
|
478
|
+
const ret = Date.now();
|
|
479
|
+
return ret;
|
|
480
|
+
},
|
|
481
|
+
__wbg_of_85f52f8b6491a7ca: function(arg0) {
|
|
482
|
+
const ret = Array.of(arg0);
|
|
483
|
+
return ret;
|
|
484
|
+
},
|
|
485
|
+
__wbg_open_90286a4ce0ae2098: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
|
|
486
|
+
arg0.open(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4), arg5 !== 0);
|
|
487
|
+
}, arguments); },
|
|
488
|
+
__wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
|
|
489
|
+
Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
|
|
490
|
+
},
|
|
491
|
+
__wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
|
|
492
|
+
const ret = arg0.push(arg1);
|
|
493
|
+
return ret;
|
|
494
|
+
},
|
|
495
|
+
__wbg_queueMicrotask_0ab5b2d2393e99b9: function(arg0) {
|
|
496
|
+
const ret = arg0.queueMicrotask;
|
|
497
|
+
return ret;
|
|
498
|
+
},
|
|
499
|
+
__wbg_queueMicrotask_6a09b7bc46549209: function(arg0) {
|
|
500
|
+
queueMicrotask(arg0);
|
|
501
|
+
},
|
|
502
|
+
__wbg_read_8afa15f12a160ef8: function(arg0) {
|
|
503
|
+
const ret = arg0.read();
|
|
504
|
+
return ret;
|
|
505
|
+
},
|
|
506
|
+
__wbg_readyState_e916e521239696c1: function(arg0) {
|
|
507
|
+
const ret = arg0.readyState;
|
|
508
|
+
return ret;
|
|
509
|
+
},
|
|
510
|
+
__wbg_removeItem_78e03a38da96e0ae: function() { return handleError(function (arg0, arg1, arg2) {
|
|
511
|
+
arg0.removeItem(getStringFromWasm0(arg1, arg2));
|
|
512
|
+
}, arguments); },
|
|
513
|
+
__wbg_resolve_2191a4dfe481c25b: function(arg0) {
|
|
514
|
+
const ret = Promise.resolve(arg0);
|
|
515
|
+
return ret;
|
|
516
|
+
},
|
|
517
|
+
__wbg_send_99f08159076e44ba: function() { return handleError(function (arg0, arg1) {
|
|
518
|
+
arg0.send(arg1);
|
|
519
|
+
}, arguments); },
|
|
520
|
+
__wbg_setInterval_93ec7461c3650c76: function() { return handleError(function (arg0, arg1, arg2) {
|
|
521
|
+
const ret = arg0.setInterval(arg1, arg2);
|
|
522
|
+
return ret;
|
|
523
|
+
}, arguments); },
|
|
524
|
+
__wbg_setItem_364a11cf21db9039: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
525
|
+
arg0.setItem(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
|
|
526
|
+
}, arguments); },
|
|
527
|
+
__wbg_setRequestHeader_fe390ff50d349432: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
528
|
+
arg0.setRequestHeader(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
|
|
529
|
+
}, arguments); },
|
|
530
|
+
__wbg_setTimeout_cfa2cf195c3738db: function() { return handleError(function (arg0, arg1, arg2) {
|
|
531
|
+
const ret = arg0.setTimeout(arg1, arg2);
|
|
532
|
+
return ret;
|
|
533
|
+
}, arguments); },
|
|
534
|
+
__wbg_set_0de9c62c23d04ad5: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
535
|
+
arg0.set(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
|
|
536
|
+
}, arguments); },
|
|
537
|
+
__wbg_set_4d7dd76f3dae2926: function(arg0, arg1, arg2) {
|
|
538
|
+
arg0.set(getArrayU8FromWasm0(arg1, arg2));
|
|
539
|
+
},
|
|
540
|
+
__wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
|
|
541
|
+
const ret = Reflect.set(arg0, arg1, arg2);
|
|
542
|
+
return ret;
|
|
543
|
+
}, arguments); },
|
|
544
|
+
__wbg_set_body_029f2d171e0a005f: function(arg0, arg1) {
|
|
545
|
+
arg0.body = arg1;
|
|
546
|
+
},
|
|
547
|
+
__wbg_set_headers_9c61d123c3ee1f10: function(arg0, arg1) {
|
|
548
|
+
arg0.headers = arg1;
|
|
549
|
+
},
|
|
550
|
+
__wbg_set_method_5532d59b92d76467: function(arg0, arg1, arg2) {
|
|
551
|
+
arg0.method = getStringFromWasm0(arg1, arg2);
|
|
552
|
+
},
|
|
553
|
+
__wbg_set_onabort_549ef96670787286: function(arg0, arg1) {
|
|
554
|
+
arg0.onabort = arg1;
|
|
555
|
+
},
|
|
556
|
+
__wbg_set_onerror_c810587e53729112: function(arg0, arg1) {
|
|
557
|
+
arg0.onerror = arg1;
|
|
558
|
+
},
|
|
559
|
+
__wbg_set_onprogress_ba0113ededd552ae: function(arg0, arg1) {
|
|
560
|
+
arg0.onprogress = arg1;
|
|
561
|
+
},
|
|
562
|
+
__wbg_set_onreadystatechange_14ce44725c7e0789: function(arg0, arg1) {
|
|
563
|
+
arg0.onreadystatechange = arg1;
|
|
564
|
+
},
|
|
565
|
+
__wbg_set_signal_c4ef8faddb4c1446: function(arg0, arg1) {
|
|
566
|
+
arg0.signal = arg1;
|
|
567
|
+
},
|
|
568
|
+
__wbg_signal_dad7cb35193abd31: function(arg0) {
|
|
569
|
+
const ret = arg0.signal;
|
|
570
|
+
return ret;
|
|
571
|
+
},
|
|
572
|
+
__wbg_size_6304a694765921a9: function(arg0) {
|
|
573
|
+
const ret = arg0.size;
|
|
574
|
+
return ret;
|
|
575
|
+
},
|
|
576
|
+
__wbg_stack_3b0d974bbf31e44f: function(arg0, arg1) {
|
|
577
|
+
const ret = arg1.stack;
|
|
578
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
579
|
+
const len1 = WASM_VECTOR_LEN;
|
|
580
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
581
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
582
|
+
},
|
|
583
|
+
__wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
|
|
584
|
+
const ret = typeof global === 'undefined' ? null : global;
|
|
585
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
586
|
+
},
|
|
587
|
+
__wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
|
|
588
|
+
const ret = typeof globalThis === 'undefined' ? null : globalThis;
|
|
589
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
590
|
+
},
|
|
591
|
+
__wbg_static_accessor_SELF_146583524fe1469b: function() {
|
|
592
|
+
const ret = typeof self === 'undefined' ? null : self;
|
|
593
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
594
|
+
},
|
|
595
|
+
__wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
|
|
596
|
+
const ret = typeof window === 'undefined' ? null : window;
|
|
597
|
+
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
598
|
+
},
|
|
599
|
+
__wbg_status_bab532bcb3b5d775: function() { return handleError(function (arg0) {
|
|
600
|
+
const ret = arg0.status;
|
|
601
|
+
return ret;
|
|
602
|
+
}, arguments); },
|
|
603
|
+
__wbg_status_c45b3b9b3033184a: function(arg0) {
|
|
604
|
+
const ret = arg0.status;
|
|
605
|
+
return ret;
|
|
606
|
+
},
|
|
607
|
+
__wbg_then_16d107c451e9905d: function(arg0, arg1, arg2) {
|
|
608
|
+
const ret = arg0.then(arg1, arg2);
|
|
609
|
+
return ret;
|
|
610
|
+
},
|
|
611
|
+
__wbg_then_6ec10ae38b3e92f7: function(arg0, arg1) {
|
|
612
|
+
const ret = arg0.then(arg1);
|
|
613
|
+
return ret;
|
|
614
|
+
},
|
|
615
|
+
__wbg_then_e0960b859f3ff223: function(arg0, arg1) {
|
|
616
|
+
const ret = arg0.then(arg1);
|
|
617
|
+
return ret;
|
|
618
|
+
},
|
|
619
|
+
__wbg_total_21672ff1bd8d23ea: function(arg0) {
|
|
620
|
+
const ret = arg0.total;
|
|
621
|
+
return ret;
|
|
622
|
+
},
|
|
623
|
+
__wbg_upload_65cdbdfcc901f1b1: function() { return handleError(function (arg0) {
|
|
624
|
+
const ret = arg0.upload;
|
|
625
|
+
return ret;
|
|
626
|
+
}, arguments); },
|
|
627
|
+
__wbindgen_cast_0000000000000001: function(arg0, arg1) {
|
|
628
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 213, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
|
|
629
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue__core_d941ad8722425d2e___result__Result_____wasm_bindgen_61f1d8f55010c370___JsError___true_);
|
|
630
|
+
return ret;
|
|
631
|
+
},
|
|
632
|
+
__wbindgen_cast_0000000000000002: function(arg0, arg1) {
|
|
633
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
634
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true_);
|
|
635
|
+
return ret;
|
|
636
|
+
},
|
|
637
|
+
__wbindgen_cast_0000000000000003: function(arg0, arg1) {
|
|
638
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ProgressEvent")], shim_idx: 4, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
639
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true__2);
|
|
640
|
+
return ret;
|
|
641
|
+
},
|
|
642
|
+
__wbindgen_cast_0000000000000004: function(arg0, arg1) {
|
|
643
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 7, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
644
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke_______true_);
|
|
645
|
+
return ret;
|
|
646
|
+
},
|
|
647
|
+
__wbindgen_cast_0000000000000005: function(arg0) {
|
|
648
|
+
// Cast intrinsic for `F64 -> Externref`.
|
|
649
|
+
const ret = arg0;
|
|
650
|
+
return ret;
|
|
651
|
+
},
|
|
652
|
+
__wbindgen_cast_0000000000000006: function(arg0, arg1) {
|
|
653
|
+
// Cast intrinsic for `Ref(String) -> Externref`.
|
|
654
|
+
const ret = getStringFromWasm0(arg0, arg1);
|
|
655
|
+
return ret;
|
|
656
|
+
},
|
|
657
|
+
__wbindgen_init_externref_table: function() {
|
|
658
|
+
const table = wasm.__wbindgen_externrefs;
|
|
659
|
+
const offset = table.grow(4);
|
|
660
|
+
table.set(0, undefined);
|
|
661
|
+
table.set(offset + 0, undefined);
|
|
662
|
+
table.set(offset + 1, null);
|
|
663
|
+
table.set(offset + 2, true);
|
|
664
|
+
table.set(offset + 3, false);
|
|
665
|
+
},
|
|
666
|
+
};
|
|
667
|
+
return {
|
|
668
|
+
__proto__: null,
|
|
669
|
+
"./libfw_client_bg.js": import0,
|
|
670
|
+
};
|
|
671
|
+
}
|
|
672
|
+
|
|
673
|
+
function wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke_______true_(arg0, arg1) {
|
|
674
|
+
wasm.wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke_______true_(arg0, arg1);
|
|
675
|
+
}
|
|
676
|
+
|
|
677
|
+
function wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true_(arg0, arg1, arg2) {
|
|
678
|
+
wasm.wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true_(arg0, arg1, arg2);
|
|
679
|
+
}
|
|
680
|
+
|
|
681
|
+
function wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true__2(arg0, arg1, arg2) {
|
|
682
|
+
wasm.wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true__2(arg0, arg1, arg2);
|
|
683
|
+
}
|
|
684
|
+
|
|
685
|
+
function wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue__core_d941ad8722425d2e___result__Result_____wasm_bindgen_61f1d8f55010c370___JsError___true_(arg0, arg1, arg2) {
|
|
686
|
+
const ret = wasm.wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue__core_d941ad8722425d2e___result__Result_____wasm_bindgen_61f1d8f55010c370___JsError___true_(arg0, arg1, arg2);
|
|
687
|
+
if (ret[1]) {
|
|
688
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
689
|
+
}
|
|
690
|
+
}
|
|
691
|
+
|
|
692
|
+
function wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined_______true_(arg0, arg1, arg2, arg3) {
|
|
693
|
+
wasm.wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined_______true_(arg0, arg1, arg2, arg3);
|
|
694
|
+
}
|
|
695
|
+
|
|
696
|
+
const LibfwClientFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
697
|
+
? { register: () => {}, unregister: () => {} }
|
|
698
|
+
: new FinalizationRegistry(ptr => wasm.__wbg_libfwclient_free(ptr, 1));
|
|
699
|
+
|
|
700
|
+
function addToExternrefTable0(obj) {
|
|
701
|
+
const idx = wasm.__externref_table_alloc();
|
|
702
|
+
wasm.__wbindgen_externrefs.set(idx, obj);
|
|
703
|
+
return idx;
|
|
704
|
+
}
|
|
705
|
+
|
|
706
|
+
const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
|
|
707
|
+
? { register: () => {}, unregister: () => {} }
|
|
708
|
+
: new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
|
|
709
|
+
|
|
710
|
+
function debugString(val) {
|
|
711
|
+
// primitive types
|
|
712
|
+
const type = typeof val;
|
|
713
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
|
714
|
+
return `${val}`;
|
|
715
|
+
}
|
|
716
|
+
if (type == 'string') {
|
|
717
|
+
return `"${val}"`;
|
|
718
|
+
}
|
|
719
|
+
if (type == 'symbol') {
|
|
720
|
+
const description = val.description;
|
|
721
|
+
if (description == null) {
|
|
722
|
+
return 'Symbol';
|
|
723
|
+
} else {
|
|
724
|
+
return `Symbol(${description})`;
|
|
725
|
+
}
|
|
726
|
+
}
|
|
727
|
+
if (type == 'function') {
|
|
728
|
+
const name = val.name;
|
|
729
|
+
if (typeof name == 'string' && name.length > 0) {
|
|
730
|
+
return `Function(${name})`;
|
|
731
|
+
} else {
|
|
732
|
+
return 'Function';
|
|
733
|
+
}
|
|
734
|
+
}
|
|
735
|
+
// objects
|
|
736
|
+
if (Array.isArray(val)) {
|
|
737
|
+
const length = val.length;
|
|
738
|
+
let debug = '[';
|
|
739
|
+
if (length > 0) {
|
|
740
|
+
debug += debugString(val[0]);
|
|
741
|
+
}
|
|
742
|
+
for(let i = 1; i < length; i++) {
|
|
743
|
+
debug += ', ' + debugString(val[i]);
|
|
744
|
+
}
|
|
745
|
+
debug += ']';
|
|
746
|
+
return debug;
|
|
747
|
+
}
|
|
748
|
+
// Test for built-in
|
|
749
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
750
|
+
let className;
|
|
751
|
+
if (builtInMatches && builtInMatches.length > 1) {
|
|
752
|
+
className = builtInMatches[1];
|
|
753
|
+
} else {
|
|
754
|
+
// Failed to match the standard '[object ClassName]'
|
|
755
|
+
return toString.call(val);
|
|
756
|
+
}
|
|
757
|
+
if (className == 'Object') {
|
|
758
|
+
// we're a user defined class or Object
|
|
759
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
|
760
|
+
// easier than looping through ownProperties of `val`.
|
|
761
|
+
try {
|
|
762
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
|
763
|
+
} catch (_) {
|
|
764
|
+
return 'Object';
|
|
765
|
+
}
|
|
766
|
+
}
|
|
767
|
+
// errors
|
|
768
|
+
if (val instanceof Error) {
|
|
769
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
770
|
+
}
|
|
771
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
772
|
+
return className;
|
|
773
|
+
}
|
|
774
|
+
|
|
775
|
+
function getArrayU8FromWasm0(ptr, len) {
|
|
776
|
+
ptr = ptr >>> 0;
|
|
777
|
+
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
778
|
+
}
|
|
779
|
+
|
|
780
|
+
let cachedDataViewMemory0 = null;
|
|
781
|
+
function getDataViewMemory0() {
|
|
782
|
+
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
783
|
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
784
|
+
}
|
|
785
|
+
return cachedDataViewMemory0;
|
|
786
|
+
}
|
|
787
|
+
|
|
788
|
+
function getStringFromWasm0(ptr, len) {
|
|
789
|
+
return decodeText(ptr >>> 0, len);
|
|
790
|
+
}
|
|
791
|
+
|
|
792
|
+
let cachedUint8ArrayMemory0 = null;
|
|
793
|
+
function getUint8ArrayMemory0() {
|
|
794
|
+
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
795
|
+
cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
|
|
796
|
+
}
|
|
797
|
+
return cachedUint8ArrayMemory0;
|
|
798
|
+
}
|
|
799
|
+
|
|
800
|
+
function handleError(f, args) {
|
|
801
|
+
try {
|
|
802
|
+
return f.apply(this, args);
|
|
803
|
+
} catch (e) {
|
|
804
|
+
const idx = addToExternrefTable0(e);
|
|
805
|
+
wasm.__wbindgen_exn_store(idx);
|
|
806
|
+
}
|
|
807
|
+
}
|
|
808
|
+
|
|
809
|
+
function isLikeNone(x) {
|
|
810
|
+
return x === undefined || x === null;
|
|
811
|
+
}
|
|
812
|
+
|
|
813
|
+
function makeMutClosure(arg0, arg1, f) {
|
|
814
|
+
const state = { a: arg0, b: arg1, cnt: 1 };
|
|
815
|
+
const real = (...args) => {
|
|
816
|
+
|
|
817
|
+
// First up with a closure we increment the internal reference
|
|
818
|
+
// count. This ensures that the Rust closure environment won't
|
|
819
|
+
// be deallocated while we're invoking it.
|
|
820
|
+
state.cnt++;
|
|
821
|
+
const a = state.a;
|
|
822
|
+
state.a = 0;
|
|
823
|
+
try {
|
|
824
|
+
return f(a, state.b, ...args);
|
|
825
|
+
} finally {
|
|
826
|
+
state.a = a;
|
|
827
|
+
real._wbg_cb_unref();
|
|
828
|
+
}
|
|
829
|
+
};
|
|
830
|
+
real._wbg_cb_unref = () => {
|
|
831
|
+
if (--state.cnt === 0) {
|
|
832
|
+
wasm.__wbindgen_destroy_closure(state.a, state.b);
|
|
833
|
+
state.a = 0;
|
|
834
|
+
CLOSURE_DTORS.unregister(state);
|
|
835
|
+
}
|
|
836
|
+
};
|
|
837
|
+
CLOSURE_DTORS.register(real, state, state);
|
|
838
|
+
return real;
|
|
839
|
+
}
|
|
840
|
+
|
|
841
|
+
function passStringToWasm0(arg, malloc, realloc) {
|
|
842
|
+
if (realloc === undefined) {
|
|
843
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
844
|
+
const ptr = malloc(buf.length, 1) >>> 0;
|
|
845
|
+
getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
|
|
846
|
+
WASM_VECTOR_LEN = buf.length;
|
|
847
|
+
return ptr;
|
|
848
|
+
}
|
|
849
|
+
|
|
850
|
+
let len = arg.length;
|
|
851
|
+
let ptr = malloc(len, 1) >>> 0;
|
|
852
|
+
|
|
853
|
+
const mem = getUint8ArrayMemory0();
|
|
854
|
+
|
|
855
|
+
let offset = 0;
|
|
856
|
+
|
|
857
|
+
for (; offset < len; offset++) {
|
|
858
|
+
const code = arg.charCodeAt(offset);
|
|
859
|
+
if (code > 0x7F) break;
|
|
860
|
+
mem[ptr + offset] = code;
|
|
861
|
+
}
|
|
862
|
+
if (offset !== len) {
|
|
863
|
+
if (offset !== 0) {
|
|
864
|
+
arg = arg.slice(offset);
|
|
865
|
+
}
|
|
866
|
+
ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
|
|
867
|
+
const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
|
|
868
|
+
const ret = cachedTextEncoder.encodeInto(arg, view);
|
|
869
|
+
|
|
870
|
+
offset += ret.written;
|
|
871
|
+
ptr = realloc(ptr, len, offset, 1) >>> 0;
|
|
872
|
+
}
|
|
873
|
+
|
|
874
|
+
WASM_VECTOR_LEN = offset;
|
|
875
|
+
return ptr;
|
|
876
|
+
}
|
|
877
|
+
|
|
878
|
+
function takeFromExternrefTable0(idx) {
|
|
879
|
+
const value = wasm.__wbindgen_externrefs.get(idx);
|
|
880
|
+
wasm.__externref_table_dealloc(idx);
|
|
881
|
+
return value;
|
|
882
|
+
}
|
|
883
|
+
|
|
884
|
+
let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
885
|
+
cachedTextDecoder.decode();
|
|
886
|
+
const MAX_SAFARI_DECODE_BYTES = 2146435072;
|
|
887
|
+
let numBytesDecoded = 0;
|
|
888
|
+
function decodeText(ptr, len) {
|
|
889
|
+
numBytesDecoded += len;
|
|
890
|
+
if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
|
|
891
|
+
cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
|
|
892
|
+
cachedTextDecoder.decode();
|
|
893
|
+
numBytesDecoded = len;
|
|
894
|
+
}
|
|
895
|
+
return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
|
|
896
|
+
}
|
|
897
|
+
|
|
898
|
+
const cachedTextEncoder = new TextEncoder();
|
|
899
|
+
|
|
900
|
+
if (!('encodeInto' in cachedTextEncoder)) {
|
|
901
|
+
cachedTextEncoder.encodeInto = function (arg, view) {
|
|
902
|
+
const buf = cachedTextEncoder.encode(arg);
|
|
903
|
+
view.set(buf);
|
|
904
|
+
return {
|
|
905
|
+
read: arg.length,
|
|
906
|
+
written: buf.length
|
|
907
|
+
};
|
|
908
|
+
};
|
|
909
|
+
}
|
|
910
|
+
|
|
911
|
+
let WASM_VECTOR_LEN = 0;
|
|
912
|
+
|
|
913
|
+
let wasmModule, wasmInstance, wasm;
|
|
914
|
+
function __wbg_finalize_init(instance, module) {
|
|
915
|
+
wasmInstance = instance;
|
|
916
|
+
wasm = instance.exports;
|
|
917
|
+
wasmModule = module;
|
|
918
|
+
cachedDataViewMemory0 = null;
|
|
919
|
+
cachedUint8ArrayMemory0 = null;
|
|
920
|
+
wasm.__wbindgen_start();
|
|
921
|
+
return wasm;
|
|
922
|
+
}
|
|
923
|
+
|
|
924
|
+
async function __wbg_load(module, imports) {
|
|
925
|
+
if (typeof Response === 'function' && module instanceof Response) {
|
|
926
|
+
if (typeof WebAssembly.instantiateStreaming === 'function') {
|
|
927
|
+
try {
|
|
928
|
+
return await WebAssembly.instantiateStreaming(module, imports);
|
|
929
|
+
} catch (e) {
|
|
930
|
+
const validResponse = module.ok && expectedResponseType(module.type);
|
|
931
|
+
|
|
932
|
+
if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
|
|
933
|
+
console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
|
|
934
|
+
|
|
935
|
+
} else { throw e; }
|
|
936
|
+
}
|
|
937
|
+
}
|
|
938
|
+
|
|
939
|
+
const bytes = await module.arrayBuffer();
|
|
940
|
+
return await WebAssembly.instantiate(bytes, imports);
|
|
941
|
+
} else {
|
|
942
|
+
const instance = await WebAssembly.instantiate(module, imports);
|
|
943
|
+
|
|
944
|
+
if (instance instanceof WebAssembly.Instance) {
|
|
945
|
+
return { instance, module };
|
|
946
|
+
} else {
|
|
947
|
+
return instance;
|
|
948
|
+
}
|
|
949
|
+
}
|
|
950
|
+
|
|
951
|
+
function expectedResponseType(type) {
|
|
952
|
+
switch (type) {
|
|
953
|
+
case 'basic': case 'cors': case 'default': return true;
|
|
954
|
+
}
|
|
955
|
+
return false;
|
|
956
|
+
}
|
|
957
|
+
}
|
|
958
|
+
|
|
959
|
+
function initSync(module) {
|
|
960
|
+
if (wasm !== undefined) return wasm;
|
|
961
|
+
|
|
962
|
+
|
|
963
|
+
if (module !== undefined) {
|
|
964
|
+
if (Object.getPrototypeOf(module) === Object.prototype) {
|
|
965
|
+
({module} = module)
|
|
966
|
+
} else {
|
|
967
|
+
console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
|
|
968
|
+
}
|
|
969
|
+
}
|
|
970
|
+
|
|
971
|
+
const imports = __wbg_get_imports();
|
|
972
|
+
if (!(module instanceof WebAssembly.Module)) {
|
|
973
|
+
module = new WebAssembly.Module(module);
|
|
974
|
+
}
|
|
975
|
+
const instance = new WebAssembly.Instance(module, imports);
|
|
976
|
+
return __wbg_finalize_init(instance, module);
|
|
977
|
+
}
|
|
978
|
+
|
|
979
|
+
async function __wbg_init(module_or_path) {
|
|
980
|
+
if (wasm !== undefined) return wasm;
|
|
981
|
+
|
|
982
|
+
|
|
983
|
+
if (module_or_path !== undefined) {
|
|
984
|
+
if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
|
|
985
|
+
({module_or_path} = module_or_path)
|
|
986
|
+
} else {
|
|
987
|
+
console.warn('using deprecated parameters for the initialization function; pass a single object instead')
|
|
988
|
+
}
|
|
989
|
+
}
|
|
990
|
+
|
|
991
|
+
if (module_or_path === undefined) {
|
|
992
|
+
module_or_path = new URL('libfw_client_bg.wasm', import.meta.url);
|
|
993
|
+
}
|
|
994
|
+
const imports = __wbg_get_imports();
|
|
995
|
+
|
|
996
|
+
if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
|
|
997
|
+
module_or_path = fetch(module_or_path);
|
|
998
|
+
}
|
|
999
|
+
|
|
1000
|
+
const { instance, module } = await __wbg_load(await module_or_path, imports);
|
|
1001
|
+
|
|
1002
|
+
return __wbg_finalize_init(instance, module);
|
|
1003
|
+
}
|
|
1004
|
+
|
|
1005
|
+
export { initSync, __wbg_init as default };
|
|
Binary file
|
|
@@ -0,0 +1,35 @@
|
|
|
1
|
+
/* tslint:disable */
|
|
2
|
+
/* eslint-disable */
|
|
3
|
+
export const memory: WebAssembly.Memory;
|
|
4
|
+
export const __wbg_libfwclient_free: (a: number, b: number) => void;
|
|
5
|
+
export const js_option_string: (a: any, b: number, c: number) => [number, number];
|
|
6
|
+
export const libfwclient_cancel: (a: number) => void;
|
|
7
|
+
export const libfwclient_done_bytes: (a: number) => number;
|
|
8
|
+
export const libfwclient_download_file: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
|
|
9
|
+
export const libfwclient_download_folder: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => any;
|
|
10
|
+
export const libfwclient_has_callbacks: (a: number) => number;
|
|
11
|
+
export const libfwclient_new: (a: any) => number;
|
|
12
|
+
export const libfwclient_pause: (a: number) => void;
|
|
13
|
+
export const libfwclient_progress: (a: number) => number;
|
|
14
|
+
export const libfwclient_resume: (a: number) => void;
|
|
15
|
+
export const libfwclient_set_callbacks: (a: number, b: any) => void;
|
|
16
|
+
export const libfwclient_set_tune_callback: (a: number, b: any) => void;
|
|
17
|
+
export const libfwclient_state: (a: number) => [number, number];
|
|
18
|
+
export const libfwclient_total_bytes: (a: number) => number;
|
|
19
|
+
export const libfwclient_tune_state: (a: number) => any;
|
|
20
|
+
export const libfwclient_upload: (a: number, b: number, c: number, d: number, e: number) => any;
|
|
21
|
+
export const start: () => void;
|
|
22
|
+
export const wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue__core_d941ad8722425d2e___result__Result_____wasm_bindgen_61f1d8f55010c370___JsError___true_: (a: number, b: number, c: any) => [number, number];
|
|
23
|
+
export const wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined___js_sys_aae1c6745bd75fc1___Function_fn_wasm_bindgen_61f1d8f55010c370___JsValue_____wasm_bindgen_61f1d8f55010c370___sys__Undefined_______true_: (a: number, b: number, c: any, d: any) => void;
|
|
24
|
+
export const wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true_: (a: number, b: number, c: any) => void;
|
|
25
|
+
export const wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke___wasm_bindgen_61f1d8f55010c370___JsValue______true__2: (a: number, b: number, c: any) => void;
|
|
26
|
+
export const wasm_bindgen_61f1d8f55010c370___convert__closures_____invoke_______true_: (a: number, b: number) => void;
|
|
27
|
+
export const __wbindgen_malloc: (a: number, b: number) => number;
|
|
28
|
+
export const __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
|
|
29
|
+
export const __wbindgen_exn_store: (a: number) => void;
|
|
30
|
+
export const __externref_table_alloc: () => number;
|
|
31
|
+
export const __wbindgen_externrefs: WebAssembly.Table;
|
|
32
|
+
export const __wbindgen_free: (a: number, b: number, c: number) => void;
|
|
33
|
+
export const __wbindgen_destroy_closure: (a: number, b: number) => void;
|
|
34
|
+
export const __externref_table_dealloc: (a: number) => void;
|
|
35
|
+
export const __wbindgen_start: () => void;
|
package/pkg/package.json
ADDED
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "libfw-client",
|
|
3
|
+
"type": "module",
|
|
4
|
+
"description": "libfw client: native Rust client + WASM engine + JS SDK",
|
|
5
|
+
"version": "0.4.8",
|
|
6
|
+
"license": "MIT",
|
|
7
|
+
"repository": {
|
|
8
|
+
"type": "git",
|
|
9
|
+
"url": "https://github.com/ArthurZhou/libfw"
|
|
10
|
+
},
|
|
11
|
+
"files": [
|
|
12
|
+
"libfw_client_bg.wasm",
|
|
13
|
+
"libfw_client.js",
|
|
14
|
+
"libfw_client.d.ts"
|
|
15
|
+
],
|
|
16
|
+
"main": "libfw_client.js",
|
|
17
|
+
"types": "libfw_client.d.ts",
|
|
18
|
+
"sideEffects": [
|
|
19
|
+
"./snippets/*"
|
|
20
|
+
],
|
|
21
|
+
"keywords": [
|
|
22
|
+
"wasm",
|
|
23
|
+
"browser",
|
|
24
|
+
"upload",
|
|
25
|
+
"download",
|
|
26
|
+
"resumable"
|
|
27
|
+
]
|
|
28
|
+
}
|