@techui/scifi 0.0.6-alpha.1 → 0.1.0-alpha.1

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.
Files changed (14) hide show
  1. package/README.md +88 -5
  2. package/TECHUI.md +38 -40
  3. package/UPDATE.md +62 -8
  4. package/core/core.d.ts +329 -200
  5. package/core/core.js +1275 -1218
  6. package/core/core_bg.wasm +0 -0
  7. package/core/core_bg.wasm.d.ts +67 -64
  8. package/dist/index.css +1 -1
  9. package/dist/index.js +1 -1
  10. package/index.js +190 -112
  11. package/package.json +6 -6
  12. package/dist/modules/echartsTheme.js +0 -1
  13. package/dist/modules/tuiEcharts.js +0 -1
  14. package/dist/modules/tuiEchartsMap.js +0 -1
package/core/core.js CHANGED
@@ -1,288 +1,199 @@
1
- let wasm;
1
+ /* @ts-self-types="./core.d.ts" */
2
2
 
3
- const heap = new Array(128).fill(undefined);
4
-
5
- heap.push(undefined, null, true, false);
6
-
7
- function getObject(idx) { return heap[idx]; }
8
-
9
- const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
10
-
11
- if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
12
-
13
- let cachedUint8ArrayMemory0 = null;
14
-
15
- function getUint8ArrayMemory0() {
16
- if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
17
- cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
18
- }
19
- return cachedUint8ArrayMemory0;
20
- }
21
-
22
- function getStringFromWasm0(ptr, len) {
23
- ptr = ptr >>> 0;
24
- return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
25
- }
26
-
27
- let heap_next = heap.length;
28
-
29
- function addHeapObject(obj) {
30
- if (heap_next === heap.length) heap.push(heap.length + 1);
31
- const idx = heap_next;
32
- heap_next = heap[idx];
33
-
34
- heap[idx] = obj;
35
- return idx;
3
+ /**
4
+ * @param {any} config_js
5
+ * @returns {any}
6
+ */
7
+ export function adptCalc(config_js) {
8
+ const ret = wasm.adptCalc(addHeapObject(config_js));
9
+ return takeObject(ret);
36
10
  }
37
11
 
38
- function handleError(f, args) {
12
+ /**
13
+ * @param {string} input
14
+ * @param {number} pad
15
+ * @returns {string}
16
+ */
17
+ export function b64_rpl_proc(input, pad) {
18
+ let deferred2_0;
19
+ let deferred2_1;
39
20
  try {
40
- return f.apply(this, args);
41
- } catch (e) {
42
- wasm.__wbindgen_export_0(addHeapObject(e));
21
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
22
+ const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
23
+ const len0 = WASM_VECTOR_LEN;
24
+ wasm.b64_rpl_proc(retptr, ptr0, len0, pad);
25
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
26
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
27
+ deferred2_0 = r0;
28
+ deferred2_1 = r1;
29
+ return getStringFromWasm0(r0, r1);
30
+ } finally {
31
+ wasm.__wbindgen_add_to_stack_pointer(16);
32
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
43
33
  }
44
34
  }
45
35
 
46
- function dropObject(idx) {
47
- if (idx < 132) return;
48
- heap[idx] = heap_next;
49
- heap_next = idx;
50
- }
51
-
52
- function takeObject(idx) {
53
- const ret = getObject(idx);
54
- dropObject(idx);
55
- return ret;
56
- }
57
-
58
- function isLikeNone(x) {
59
- return x === undefined || x === null;
36
+ /**
37
+ * @param {string} input
38
+ * @param {boolean} has_pad
39
+ * @returns {string}
40
+ */
41
+ export function b64_rpl_revt(input, has_pad) {
42
+ let deferred2_0;
43
+ let deferred2_1;
44
+ try {
45
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
46
+ const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
47
+ const len0 = WASM_VECTOR_LEN;
48
+ wasm.b64_rpl_revt(retptr, ptr0, len0, has_pad);
49
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
50
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
51
+ deferred2_0 = r0;
52
+ deferred2_1 = r1;
53
+ return getStringFromWasm0(r0, r1);
54
+ } finally {
55
+ wasm.__wbindgen_add_to_stack_pointer(16);
56
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
57
+ }
60
58
  }
61
59
 
62
- let WASM_VECTOR_LEN = 0;
63
-
64
- const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
65
-
66
- const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
67
- ? function (arg, view) {
68
- return cachedTextEncoder.encodeInto(arg, view);
60
+ /**
61
+ * @param {string} shape
62
+ * @param {number} width
63
+ * @param {number} height
64
+ * @param {number} top_margin
65
+ * @param {number} max_height
66
+ * @param {number} percent
67
+ * @param {number} view_deep
68
+ * @returns {any}
69
+ */
70
+ export function bar3DPathGen(shape, width, height, top_margin, max_height, percent, view_deep) {
71
+ const ptr0 = passStringToWasm0(shape, wasm.__wbindgen_export, wasm.__wbindgen_export2);
72
+ const len0 = WASM_VECTOR_LEN;
73
+ const ret = wasm.bar3DPathGen(ptr0, len0, width, height, top_margin, max_height, percent, view_deep);
74
+ return takeObject(ret);
69
75
  }
70
- : function (arg, view) {
71
- const buf = cachedTextEncoder.encode(arg);
72
- view.set(buf);
73
- return {
74
- read: arg.length,
75
- written: buf.length
76
- };
77
- });
78
-
79
- function passStringToWasm0(arg, malloc, realloc) {
80
-
81
- if (realloc === undefined) {
82
- const buf = cachedTextEncoder.encode(arg);
83
- const ptr = malloc(buf.length, 1) >>> 0;
84
- getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
85
- WASM_VECTOR_LEN = buf.length;
86
- return ptr;
87
- }
88
-
89
- let len = arg.length;
90
- let ptr = malloc(len, 1) >>> 0;
91
-
92
- const mem = getUint8ArrayMemory0();
93
-
94
- let offset = 0;
95
-
96
- for (; offset < len; offset++) {
97
- const code = arg.charCodeAt(offset);
98
- if (code > 0x7F) break;
99
- mem[ptr + offset] = code;
100
- }
101
-
102
- if (offset !== len) {
103
- if (offset !== 0) {
104
- arg = arg.slice(offset);
105
- }
106
- ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
107
- const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
108
- const ret = encodeString(arg, view);
109
76
 
110
- offset += ret.written;
111
- ptr = realloc(ptr, len, offset, 1) >>> 0;
77
+ /**
78
+ * @param {string} input
79
+ * @returns {string}
80
+ */
81
+ export function cidGen(input) {
82
+ let deferred2_0;
83
+ let deferred2_1;
84
+ try {
85
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
86
+ const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
87
+ const len0 = WASM_VECTOR_LEN;
88
+ wasm.cidGen(retptr, ptr0, len0);
89
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
90
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
91
+ deferred2_0 = r0;
92
+ deferred2_1 = r1;
93
+ return getStringFromWasm0(r0, r1);
94
+ } finally {
95
+ wasm.__wbindgen_add_to_stack_pointer(16);
96
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
112
97
  }
113
-
114
- WASM_VECTOR_LEN = offset;
115
- return ptr;
116
98
  }
117
99
 
118
- let cachedDataViewMemory0 = null;
119
-
120
- function getDataViewMemory0() {
121
- if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
122
- cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
123
- }
124
- return cachedDataViewMemory0;
100
+ /**
101
+ * @param {string} uid
102
+ * @param {string} classname
103
+ * @returns {boolean}
104
+ */
105
+ export function cidVaild(uid, classname) {
106
+ const ptr0 = passStringToWasm0(uid, wasm.__wbindgen_export, wasm.__wbindgen_export2);
107
+ const len0 = WASM_VECTOR_LEN;
108
+ const ptr1 = passStringToWasm0(classname, wasm.__wbindgen_export, wasm.__wbindgen_export2);
109
+ const len1 = WASM_VECTOR_LEN;
110
+ const ret = wasm.cidVaild(ptr0, len0, ptr1, len1);
111
+ return ret !== 0;
125
112
  }
126
113
 
127
- const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
128
- ? { register: () => {}, unregister: () => {} }
129
- : new FinalizationRegistry(state => {
130
- wasm.__wbindgen_export_3.get(state.dtor)(state.a, state.b)
131
- });
132
-
133
- function makeMutClosure(arg0, arg1, dtor, f) {
134
- const state = { a: arg0, b: arg1, cnt: 1, dtor };
135
- const real = (...args) => {
136
- // First up with a closure we increment the internal reference
137
- // count. This ensures that the Rust closure environment won't
138
- // be deallocated while we're invoking it.
139
- state.cnt++;
140
- const a = state.a;
141
- state.a = 0;
142
- try {
143
- return f(a, state.b, ...args);
144
- } finally {
145
- if (--state.cnt === 0) {
146
- wasm.__wbindgen_export_3.get(state.dtor)(a, state.b);
147
- CLOSURE_DTORS.unregister(state);
148
- } else {
149
- state.a = a;
150
- }
151
- }
152
- };
153
- real.original = state;
154
- CLOSURE_DTORS.register(real, state, state);
155
- return real;
114
+ /**
115
+ * @param {string} errstr
116
+ * @param {string} msg
117
+ */
118
+ export function coreConsoleError(errstr, msg) {
119
+ const ptr0 = passStringToWasm0(errstr, wasm.__wbindgen_export, wasm.__wbindgen_export2);
120
+ const len0 = WASM_VECTOR_LEN;
121
+ const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_export, wasm.__wbindgen_export2);
122
+ const len1 = WASM_VECTOR_LEN;
123
+ wasm.coreConsoleError(ptr0, len0, ptr1, len1);
156
124
  }
157
125
 
158
- function debugString(val) {
159
- // primitive types
160
- const type = typeof val;
161
- if (type == 'number' || type == 'boolean' || val == null) {
162
- return `${val}`;
163
- }
164
- if (type == 'string') {
165
- return `"${val}"`;
166
- }
167
- if (type == 'symbol') {
168
- const description = val.description;
169
- if (description == null) {
170
- return 'Symbol';
171
- } else {
172
- return `Symbol(${description})`;
173
- }
174
- }
175
- if (type == 'function') {
176
- const name = val.name;
177
- if (typeof name == 'string' && name.length > 0) {
178
- return `Function(${name})`;
179
- } else {
180
- return 'Function';
181
- }
182
- }
183
- // objects
184
- if (Array.isArray(val)) {
185
- const length = val.length;
186
- let debug = '[';
187
- if (length > 0) {
188
- debug += debugString(val[0]);
189
- }
190
- for(let i = 1; i < length; i++) {
191
- debug += ', ' + debugString(val[i]);
192
- }
193
- debug += ']';
194
- return debug;
195
- }
196
- // Test for built-in
197
- const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
198
- let className;
199
- if (builtInMatches && builtInMatches.length > 1) {
200
- className = builtInMatches[1];
201
- } else {
202
- // Failed to match the standard '[object ClassName]'
203
- return toString.call(val);
204
- }
205
- if (className == 'Object') {
206
- // we're a user defined class or Object
207
- // JSON.stringify avoids problems with cycles, and is generally much
208
- // easier than looping through ownProperties of `val`.
209
- try {
210
- return 'Object(' + JSON.stringify(val) + ')';
211
- } catch (_) {
212
- return 'Object';
213
- }
214
- }
215
- // errors
216
- if (val instanceof Error) {
217
- return `${val.name}: ${val.message}\n${val.stack}`;
218
- }
219
- // TODO we could test for more things here, like `Set`s and `Map`s.
220
- return className;
221
- }
222
126
  /**
223
- * @param {any} config_js
224
- * @returns {any}
127
+ * @param {string} infostr
128
+ * @param {string} msg
225
129
  */
226
- export function adptCalc(config_js) {
227
- const ret = wasm.adptCalc(addHeapObject(config_js));
228
- return takeObject(ret);
130
+ export function coreConsoleInfo(infostr, msg) {
131
+ const ptr0 = passStringToWasm0(infostr, wasm.__wbindgen_export, wasm.__wbindgen_export2);
132
+ const len0 = WASM_VECTOR_LEN;
133
+ const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_export, wasm.__wbindgen_export2);
134
+ const len1 = WASM_VECTOR_LEN;
135
+ wasm.coreConsoleInfo(ptr0, len0, ptr1, len1);
229
136
  }
230
137
 
231
138
  /**
232
- * @param {string} mode
233
- * @param {number} coeff
234
- * @param {MouseEvent} e
235
- * @param {DOMRect} el
236
- * @param {number} dh
237
- * @param {number} dw
238
- * @returns {any}
139
+ * @param {string} warnstr
140
+ * @param {string} msg
239
141
  */
240
- export function t3dUpdateRotate(mode, coeff, e, el, dh, dw) {
241
- const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
142
+ export function coreConsoleWarn(warnstr, msg) {
143
+ const ptr0 = passStringToWasm0(warnstr, wasm.__wbindgen_export, wasm.__wbindgen_export2);
242
144
  const len0 = WASM_VECTOR_LEN;
243
- const ret = wasm.t3dUpdateRotate(ptr0, len0, coeff, addHeapObject(e), addHeapObject(el), dh, dw);
244
- return takeObject(ret);
145
+ const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_export, wasm.__wbindgen_export2);
146
+ const len1 = WASM_VECTOR_LEN;
147
+ wasm.coreConsoleWarn(ptr0, len0, ptr1, len1);
245
148
  }
246
149
 
247
150
  /**
248
- * @param {number} coeff_ori
249
- * @param {number} shadow_coeff_ori
250
- * @param {number} dw
151
+ * @param {any} input
251
152
  * @returns {any}
252
153
  */
253
- export function t3dCoeffCalc(coeff_ori, shadow_coeff_ori, dw) {
254
- const ret = wasm.t3dCoeffCalc(coeff_ori, shadow_coeff_ori, dw);
154
+ export function coreInfo(input) {
155
+ const ret = wasm.coreInfo(addHeapObject(input));
255
156
  return takeObject(ret);
256
157
  }
257
158
 
258
159
  /**
259
- * @param {object} event
260
- * @param {number} fix_alpha
261
- * @param {boolean} ues_alpha
262
- * @returns {object}
160
+ * @param {string} prefix
161
+ * @param {object} style_obj
162
+ * @returns {string}
263
163
  */
264
- export function t3dUpdateOrient(event, fix_alpha, ues_alpha) {
265
- const ret = wasm.t3dUpdateOrient(addHeapObject(event), fix_alpha, ues_alpha);
266
- return takeObject(ret);
164
+ export function cssVarGen(prefix, style_obj) {
165
+ let deferred2_0;
166
+ let deferred2_1;
167
+ try {
168
+ const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
169
+ const ptr0 = passStringToWasm0(prefix, wasm.__wbindgen_export, wasm.__wbindgen_export2);
170
+ const len0 = WASM_VECTOR_LEN;
171
+ wasm.cssVarGen(retptr, ptr0, len0, addBorrowedObject(style_obj));
172
+ var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
173
+ var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
174
+ deferred2_0 = r0;
175
+ deferred2_1 = r1;
176
+ return getStringFromWasm0(r0, r1);
177
+ } finally {
178
+ wasm.__wbindgen_add_to_stack_pointer(16);
179
+ heap[stack_pointer++] = undefined;
180
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
181
+ }
182
+ }
183
+
184
+ export function floatInfo() {
185
+ wasm.floatInfo();
267
186
  }
268
187
 
269
188
  /**
270
- * @param {number} cx
271
- * @param {number} cy
272
- * @param {number} base_radius
273
- * @param {number} base_inner_radius
274
- * @param {number} start_angle_rad
275
- * @param {number} end_angle_rad
276
- * @param {number} corner_radius
277
- * @param {number} gap_distance
278
189
  * @returns {string}
279
190
  */
280
- export function pieArcPathGen(cx, cy, base_radius, base_inner_radius, start_angle_rad, end_angle_rad, corner_radius, gap_distance) {
191
+ export function getEnv() {
281
192
  let deferred1_0;
282
193
  let deferred1_1;
283
194
  try {
284
195
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
285
- wasm.pieArcPathGen(retptr, cx, cy, base_radius, base_inner_radius, start_angle_rad, end_angle_rad, corner_radius, gap_distance);
196
+ wasm.getEnv(retptr);
286
197
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
287
198
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
288
199
  deferred1_0 = r0;
@@ -290,36 +201,19 @@ export function pieArcPathGen(cx, cy, base_radius, base_inner_radius, start_angl
290
201
  return getStringFromWasm0(r0, r1);
291
202
  } finally {
292
203
  wasm.__wbindgen_add_to_stack_pointer(16);
293
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
204
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
294
205
  }
295
206
  }
296
207
 
297
- /**
298
- * @param {string} shape
299
- * @param {number} width
300
- * @param {number} height
301
- * @param {number} top_margin
302
- * @param {number} max_height
303
- * @param {number} percent
304
- * @param {number} view_deep
305
- * @returns {any}
306
- */
307
- export function bar3DPathGen(shape, width, height, top_margin, max_height, percent, view_deep) {
308
- const ptr0 = passStringToWasm0(shape, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
309
- const len0 = WASM_VECTOR_LEN;
310
- const ret = wasm.bar3DPathGen(ptr0, len0, width, height, top_margin, max_height, percent, view_deep);
311
- return takeObject(ret);
312
- }
313
-
314
208
  /**
315
209
  * @returns {string}
316
210
  */
317
- export function svgPatTest() {
211
+ export function getVer() {
318
212
  let deferred1_0;
319
213
  let deferred1_1;
320
214
  try {
321
215
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
322
- wasm.svgPatBlocks(retptr);
216
+ wasm.getVer(retptr);
323
217
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
324
218
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
325
219
  deferred1_0 = r0;
@@ -327,79 +221,102 @@ export function svgPatTest() {
327
221
  return getStringFromWasm0(r0, r1);
328
222
  } finally {
329
223
  wasm.__wbindgen_add_to_stack_pointer(16);
330
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
224
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
331
225
  }
332
226
  }
333
227
 
334
228
  /**
229
+ * @param {string} input
335
230
  * @returns {string}
336
231
  */
337
- export function svgPatBlocks() {
338
- let deferred1_0;
339
- let deferred1_1;
232
+ export function md5Enc(input) {
233
+ let deferred2_0;
234
+ let deferred2_1;
340
235
  try {
341
236
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
342
- wasm.svgPatBlocks(retptr);
237
+ const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export, wasm.__wbindgen_export2);
238
+ const len0 = WASM_VECTOR_LEN;
239
+ wasm.md5Enc(retptr, ptr0, len0);
343
240
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
344
241
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
345
- deferred1_0 = r0;
346
- deferred1_1 = r1;
242
+ deferred2_0 = r0;
243
+ deferred2_1 = r1;
347
244
  return getStringFromWasm0(r0, r1);
348
245
  } finally {
349
246
  wasm.__wbindgen_add_to_stack_pointer(16);
350
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
247
+ wasm.__wbindgen_export4(deferred2_0, deferred2_1, 1);
351
248
  }
352
249
  }
353
250
 
354
251
  /**
252
+ * @param {string} ciphertext
253
+ * @param {string} key_type
355
254
  * @returns {string}
356
255
  */
357
- export function svgPatCircuitDiagram() {
358
- let deferred1_0;
359
- let deferred1_1;
256
+ export function openDec(ciphertext, key_type) {
257
+ let deferred3_0;
258
+ let deferred3_1;
360
259
  try {
361
260
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
362
- wasm.svgPatCircuitDiagram(retptr);
261
+ const ptr0 = passStringToWasm0(ciphertext, wasm.__wbindgen_export, wasm.__wbindgen_export2);
262
+ const len0 = WASM_VECTOR_LEN;
263
+ const ptr1 = passStringToWasm0(key_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
264
+ const len1 = WASM_VECTOR_LEN;
265
+ wasm.openDec(retptr, ptr0, len0, ptr1, len1);
363
266
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
364
267
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
365
- deferred1_0 = r0;
366
- deferred1_1 = r1;
268
+ deferred3_0 = r0;
269
+ deferred3_1 = r1;
367
270
  return getStringFromWasm0(r0, r1);
368
271
  } finally {
369
272
  wasm.__wbindgen_add_to_stack_pointer(16);
370
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
273
+ wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
371
274
  }
372
275
  }
373
276
 
374
277
  /**
278
+ * @param {string} plaintext
279
+ * @param {string} key_type
375
280
  * @returns {string}
376
281
  */
377
- export function svgPatCircularOverlayA() {
378
- let deferred1_0;
379
- let deferred1_1;
282
+ export function openEnc(plaintext, key_type) {
283
+ let deferred3_0;
284
+ let deferred3_1;
380
285
  try {
381
286
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
382
- wasm.svgPatCircularOverlayA(retptr);
287
+ const ptr0 = passStringToWasm0(plaintext, wasm.__wbindgen_export, wasm.__wbindgen_export2);
288
+ const len0 = WASM_VECTOR_LEN;
289
+ const ptr1 = passStringToWasm0(key_type, wasm.__wbindgen_export, wasm.__wbindgen_export2);
290
+ const len1 = WASM_VECTOR_LEN;
291
+ wasm.openEnc(retptr, ptr0, len0, ptr1, len1);
383
292
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
384
293
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
385
- deferred1_0 = r0;
386
- deferred1_1 = r1;
294
+ deferred3_0 = r0;
295
+ deferred3_1 = r1;
387
296
  return getStringFromWasm0(r0, r1);
388
297
  } finally {
389
298
  wasm.__wbindgen_add_to_stack_pointer(16);
390
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
299
+ wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
391
300
  }
392
301
  }
393
302
 
394
303
  /**
304
+ * @param {number} cx
305
+ * @param {number} cy
306
+ * @param {number} base_radius
307
+ * @param {number} base_inner_radius
308
+ * @param {number} start_angle_rad
309
+ * @param {number} end_angle_rad
310
+ * @param {number} corner_radius
311
+ * @param {number} gap_distance
395
312
  * @returns {string}
396
313
  */
397
- export function svgPatCircularOverlayB() {
314
+ export function pieArcPathGen(cx, cy, base_radius, base_inner_radius, start_angle_rad, end_angle_rad, corner_radius, gap_distance) {
398
315
  let deferred1_0;
399
316
  let deferred1_1;
400
317
  try {
401
318
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
402
- wasm.svgPatCircularOverlayB(retptr);
319
+ wasm.pieArcPathGen(retptr, cx, cy, base_radius, base_inner_radius, start_angle_rad, end_angle_rad, corner_radius, gap_distance);
403
320
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
404
321
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
405
322
  deferred1_0 = r0;
@@ -407,19 +324,21 @@ export function svgPatCircularOverlayB() {
407
324
  return getStringFromWasm0(r0, r1);
408
325
  } finally {
409
326
  wasm.__wbindgen_add_to_stack_pointer(16);
410
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
327
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
411
328
  }
412
329
  }
413
330
 
414
331
  /**
332
+ * @param {number} length
333
+ * @param {boolean} has_digits
415
334
  * @returns {string}
416
335
  */
417
- export function svgPatContourLine() {
336
+ export function rdmStr(length, has_digits) {
418
337
  let deferred1_0;
419
338
  let deferred1_1;
420
339
  try {
421
340
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
422
- wasm.svgPatContourLine(retptr);
341
+ wasm.rdmStr(retptr, length, has_digits);
423
342
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
424
343
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
425
344
  deferred1_0 = r0;
@@ -427,19 +346,20 @@ export function svgPatContourLine() {
427
346
  return getStringFromWasm0(r0, r1);
428
347
  } finally {
429
348
  wasm.__wbindgen_add_to_stack_pointer(16);
430
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
349
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
431
350
  }
432
351
  }
433
352
 
434
353
  /**
354
+ * @param {number} width
435
355
  * @returns {string}
436
356
  */
437
- export function svgPatCrosshairA() {
357
+ export function scifiButtonA1(width) {
438
358
  let deferred1_0;
439
359
  let deferred1_1;
440
360
  try {
441
361
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
442
- wasm.svgPatCrosshairA(retptr);
362
+ wasm.scifiButtonA1(retptr, width);
443
363
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
444
364
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
445
365
  deferred1_0 = r0;
@@ -447,19 +367,20 @@ export function svgPatCrosshairA() {
447
367
  return getStringFromWasm0(r0, r1);
448
368
  } finally {
449
369
  wasm.__wbindgen_add_to_stack_pointer(16);
450
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
370
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
451
371
  }
452
372
  }
453
373
 
454
374
  /**
375
+ * @param {number} width
455
376
  * @returns {string}
456
377
  */
457
- export function svgPatCrosshairB() {
378
+ export function scifiButtonA2(width) {
458
379
  let deferred1_0;
459
380
  let deferred1_1;
460
381
  try {
461
382
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
462
- wasm.svgPatCrosshairB(retptr);
383
+ wasm.scifiButtonA2(retptr, width);
463
384
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
464
385
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
465
386
  deferred1_0 = r0;
@@ -467,19 +388,20 @@ export function svgPatCrosshairB() {
467
388
  return getStringFromWasm0(r0, r1);
468
389
  } finally {
469
390
  wasm.__wbindgen_add_to_stack_pointer(16);
470
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
391
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
471
392
  }
472
393
  }
473
394
 
474
395
  /**
396
+ * @param {number} width
475
397
  * @returns {string}
476
398
  */
477
- export function svgPatCubeA() {
399
+ export function scifiButtonA3(width) {
478
400
  let deferred1_0;
479
401
  let deferred1_1;
480
402
  try {
481
403
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
482
- wasm.svgPatCubeA(retptr);
404
+ wasm.scifiButtonA3(retptr, width);
483
405
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
484
406
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
485
407
  deferred1_0 = r0;
@@ -487,19 +409,20 @@ export function svgPatCubeA() {
487
409
  return getStringFromWasm0(r0, r1);
488
410
  } finally {
489
411
  wasm.__wbindgen_add_to_stack_pointer(16);
490
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
412
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
491
413
  }
492
414
  }
493
415
 
494
416
  /**
417
+ * @param {number} width
495
418
  * @returns {string}
496
419
  */
497
- export function svgPatCubeB() {
420
+ export function scifiButtonA4(width) {
498
421
  let deferred1_0;
499
422
  let deferred1_1;
500
423
  try {
501
424
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
502
- wasm.svgPatCubeB(retptr);
425
+ wasm.scifiButtonA4(retptr, width);
503
426
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
504
427
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
505
428
  deferred1_0 = r0;
@@ -507,19 +430,20 @@ export function svgPatCubeB() {
507
430
  return getStringFromWasm0(r0, r1);
508
431
  } finally {
509
432
  wasm.__wbindgen_add_to_stack_pointer(16);
510
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
433
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
511
434
  }
512
435
  }
513
436
 
514
437
  /**
438
+ * @param {number} width
515
439
  * @returns {string}
516
440
  */
517
- export function svgPatCubeC() {
441
+ export function scifiButtonA5(width) {
518
442
  let deferred1_0;
519
443
  let deferred1_1;
520
444
  try {
521
445
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
522
- wasm.svgPatCubeC(retptr);
446
+ wasm.scifiButtonA5(retptr, width);
523
447
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
524
448
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
525
449
  deferred1_0 = r0;
@@ -527,19 +451,19 @@ export function svgPatCubeC() {
527
451
  return getStringFromWasm0(r0, r1);
528
452
  } finally {
529
453
  wasm.__wbindgen_add_to_stack_pointer(16);
530
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
454
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
531
455
  }
532
456
  }
533
457
 
534
458
  /**
535
459
  * @returns {string}
536
460
  */
537
- export function svgPatDiamondFlipped() {
461
+ export function scifiDecoA1() {
538
462
  let deferred1_0;
539
463
  let deferred1_1;
540
464
  try {
541
465
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
542
- wasm.svgPatDiamondFlipped(retptr);
466
+ wasm.scifiDecoA1(retptr);
543
467
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
544
468
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
545
469
  deferred1_0 = r0;
@@ -547,19 +471,19 @@ export function svgPatDiamondFlipped() {
547
471
  return getStringFromWasm0(r0, r1);
548
472
  } finally {
549
473
  wasm.__wbindgen_add_to_stack_pointer(16);
550
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
474
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
551
475
  }
552
476
  }
553
477
 
554
478
  /**
555
479
  * @returns {string}
556
480
  */
557
- export function svgPatDiamondLattice() {
481
+ export function scifiDecoB1() {
558
482
  let deferred1_0;
559
483
  let deferred1_1;
560
484
  try {
561
485
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
562
- wasm.svgPatDiamondLattice(retptr);
486
+ wasm.scifiDecoB1(retptr);
563
487
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
564
488
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
565
489
  deferred1_0 = r0;
@@ -567,19 +491,19 @@ export function svgPatDiamondLattice() {
567
491
  return getStringFromWasm0(r0, r1);
568
492
  } finally {
569
493
  wasm.__wbindgen_add_to_stack_pointer(16);
570
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
494
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
571
495
  }
572
496
  }
573
497
 
574
498
  /**
575
499
  * @returns {string}
576
500
  */
577
- export function svgPatDiamondPixel() {
501
+ export function scifiDecoB2() {
578
502
  let deferred1_0;
579
503
  let deferred1_1;
580
504
  try {
581
505
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
582
- wasm.svgPatDiamondPixel(retptr);
506
+ wasm.scifiDecoB2(retptr);
583
507
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
584
508
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
585
509
  deferred1_0 = r0;
@@ -587,19 +511,19 @@ export function svgPatDiamondPixel() {
587
511
  return getStringFromWasm0(r0, r1);
588
512
  } finally {
589
513
  wasm.__wbindgen_add_to_stack_pointer(16);
590
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
514
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
591
515
  }
592
516
  }
593
517
 
594
518
  /**
595
519
  * @returns {string}
596
520
  */
597
- export function svgPatDiamondWeaving() {
521
+ export function scifiDecoB3() {
598
522
  let deferred1_0;
599
523
  let deferred1_1;
600
524
  try {
601
525
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
602
- wasm.svgPatDiamondWeaving(retptr);
526
+ wasm.scifiDecoB3(retptr);
603
527
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
604
528
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
605
529
  deferred1_0 = r0;
@@ -607,19 +531,19 @@ export function svgPatDiamondWeaving() {
607
531
  return getStringFromWasm0(r0, r1);
608
532
  } finally {
609
533
  wasm.__wbindgen_add_to_stack_pointer(16);
610
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
534
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
611
535
  }
612
536
  }
613
537
 
614
538
  /**
615
539
  * @returns {string}
616
540
  */
617
- export function svgPatDots() {
541
+ export function scifiDecoD1() {
618
542
  let deferred1_0;
619
543
  let deferred1_1;
620
544
  try {
621
545
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
622
- wasm.svgPatDots(retptr);
546
+ wasm.scifiDecoD1(retptr);
623
547
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
624
548
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
625
549
  deferred1_0 = r0;
@@ -627,19 +551,21 @@ export function svgPatDots() {
627
551
  return getStringFromWasm0(r0, r1);
628
552
  } finally {
629
553
  wasm.__wbindgen_add_to_stack_pointer(16);
630
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
554
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
631
555
  }
632
556
  }
633
557
 
634
558
  /**
559
+ * @param {number} width
560
+ * @param {number} height
635
561
  * @returns {string}
636
562
  */
637
- export function svgPatHexagonA() {
563
+ export function scifiGeomHexagon(width, height) {
638
564
  let deferred1_0;
639
565
  let deferred1_1;
640
566
  try {
641
567
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
642
- wasm.svgPatHexagonA(retptr);
568
+ wasm.scifiGeomHexagon(retptr, width, height);
643
569
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
644
570
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
645
571
  deferred1_0 = r0;
@@ -647,19 +573,21 @@ export function svgPatHexagonA() {
647
573
  return getStringFromWasm0(r0, r1);
648
574
  } finally {
649
575
  wasm.__wbindgen_add_to_stack_pointer(16);
650
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
576
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
651
577
  }
652
578
  }
653
579
 
654
580
  /**
581
+ * @param {number} width
582
+ * @param {number} height
655
583
  * @returns {string}
656
584
  */
657
- export function svgPatHexagonB() {
585
+ export function scifiGeomeParallelogram(width, height) {
658
586
  let deferred1_0;
659
587
  let deferred1_1;
660
588
  try {
661
589
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
662
- wasm.svgPatHexagonB(retptr);
590
+ wasm.scifiGeomeParallelogram(retptr, width, height);
663
591
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
664
592
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
665
593
  deferred1_0 = r0;
@@ -667,19 +595,21 @@ export function svgPatHexagonB() {
667
595
  return getStringFromWasm0(r0, r1);
668
596
  } finally {
669
597
  wasm.__wbindgen_add_to_stack_pointer(16);
670
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
598
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
671
599
  }
672
600
  }
673
601
 
674
602
  /**
603
+ * @param {number} width
604
+ * @param {number} height
675
605
  * @returns {string}
676
606
  */
677
- export function svgPatHexagonC() {
607
+ export function scifiGeomeRectangle(width, height) {
678
608
  let deferred1_0;
679
609
  let deferred1_1;
680
610
  try {
681
611
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
682
- wasm.svgPatHexagonC(retptr);
612
+ wasm.scifiGeomeRectangle(retptr, width, height);
683
613
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
684
614
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
685
615
  deferred1_0 = r0;
@@ -687,19 +617,21 @@ export function svgPatHexagonC() {
687
617
  return getStringFromWasm0(r0, r1);
688
618
  } finally {
689
619
  wasm.__wbindgen_add_to_stack_pointer(16);
690
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
620
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
691
621
  }
692
622
  }
693
623
 
694
624
  /**
625
+ * @param {number} width
626
+ * @param {number} height
695
627
  * @returns {string}
696
628
  */
697
- export function svgPatHexagonD() {
629
+ export function scifiGeomeTrapezoid(width, height) {
698
630
  let deferred1_0;
699
631
  let deferred1_1;
700
632
  try {
701
633
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
702
- wasm.svgPatHexagonD(retptr);
634
+ wasm.scifiGeomeTrapezoid(retptr, width, height);
703
635
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
704
636
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
705
637
  deferred1_0 = r0;
@@ -707,19 +639,21 @@ export function svgPatHexagonD() {
707
639
  return getStringFromWasm0(r0, r1);
708
640
  } finally {
709
641
  wasm.__wbindgen_add_to_stack_pointer(16);
710
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
642
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
711
643
  }
712
644
  }
713
645
 
714
646
  /**
647
+ * @param {number} width
648
+ * @param {number} height
715
649
  * @returns {string}
716
650
  */
717
- export function svgPatHexagonCurved() {
651
+ export function scifiGeomeTriangle(width, height) {
718
652
  let deferred1_0;
719
653
  let deferred1_1;
720
654
  try {
721
655
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
722
- wasm.svgPatHexagonCurved(retptr);
656
+ wasm.scifiGeomeTriangle(retptr, width, height);
723
657
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
724
658
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
725
659
  deferred1_0 = r0;
@@ -727,19 +661,20 @@ export function svgPatHexagonCurved() {
727
661
  return getStringFromWasm0(r0, r1);
728
662
  } finally {
729
663
  wasm.__wbindgen_add_to_stack_pointer(16);
730
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
664
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
731
665
  }
732
666
  }
733
667
 
734
668
  /**
669
+ * @param {number} width
735
670
  * @returns {string}
736
671
  */
737
- export function svgPatLineGrid() {
672
+ export function scifiHeaderA1(width) {
738
673
  let deferred1_0;
739
674
  let deferred1_1;
740
675
  try {
741
676
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
742
- wasm.svgPatLineGrid(retptr);
677
+ wasm.scifiHeaderA1(retptr, width);
743
678
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
744
679
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
745
680
  deferred1_0 = r0;
@@ -747,19 +682,20 @@ export function svgPatLineGrid() {
747
682
  return getStringFromWasm0(r0, r1);
748
683
  } finally {
749
684
  wasm.__wbindgen_add_to_stack_pointer(16);
750
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
685
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
751
686
  }
752
687
  }
753
688
 
754
689
  /**
690
+ * @param {number} width
755
691
  * @returns {string}
756
692
  */
757
- export function svgPatLineWeaving() {
693
+ export function scifiHeaderA2(width) {
758
694
  let deferred1_0;
759
695
  let deferred1_1;
760
696
  try {
761
697
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
762
- wasm.svgPatLineWeaving(retptr);
698
+ wasm.scifiHeaderA2(retptr, width);
763
699
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
764
700
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
765
701
  deferred1_0 = r0;
@@ -767,19 +703,20 @@ export function svgPatLineWeaving() {
767
703
  return getStringFromWasm0(r0, r1);
768
704
  } finally {
769
705
  wasm.__wbindgen_add_to_stack_pointer(16);
770
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
706
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
771
707
  }
772
708
  }
773
709
 
774
710
  /**
711
+ * @param {number} width
775
712
  * @returns {string}
776
713
  */
777
- export function svgPatMazeA() {
714
+ export function scifiHeaderA3(width) {
778
715
  let deferred1_0;
779
716
  let deferred1_1;
780
717
  try {
781
718
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
782
- wasm.svgPatMazeA(retptr);
719
+ wasm.scifiHeaderA3(retptr, width);
783
720
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
784
721
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
785
722
  deferred1_0 = r0;
@@ -787,19 +724,20 @@ export function svgPatMazeA() {
787
724
  return getStringFromWasm0(r0, r1);
788
725
  } finally {
789
726
  wasm.__wbindgen_add_to_stack_pointer(16);
790
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
727
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
791
728
  }
792
729
  }
793
730
 
794
731
  /**
732
+ * @param {number} width
795
733
  * @returns {string}
796
734
  */
797
- export function svgPatMazeB() {
735
+ export function scifiHeaderA4(width) {
798
736
  let deferred1_0;
799
737
  let deferred1_1;
800
738
  try {
801
739
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
802
- wasm.svgPatMazeB(retptr);
740
+ wasm.scifiHeaderA4(retptr, width);
803
741
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
804
742
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
805
743
  deferred1_0 = r0;
@@ -807,19 +745,22 @@ export function svgPatMazeB() {
807
745
  return getStringFromWasm0(r0, r1);
808
746
  } finally {
809
747
  wasm.__wbindgen_add_to_stack_pointer(16);
810
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
748
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
811
749
  }
812
750
  }
813
751
 
814
752
  /**
753
+ * @param {number} width
754
+ * @param {number} height
755
+ * @param {number} twidth
815
756
  * @returns {string}
816
757
  */
817
- export function svgPatMazeC() {
758
+ export function scifiPanelA1(width, height, twidth) {
818
759
  let deferred1_0;
819
760
  let deferred1_1;
820
761
  try {
821
762
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
822
- wasm.svgPatMazeC(retptr);
763
+ wasm.scifiPanelA1(retptr, width, height, twidth);
823
764
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
824
765
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
825
766
  deferred1_0 = r0;
@@ -827,19 +768,21 @@ export function svgPatMazeC() {
827
768
  return getStringFromWasm0(r0, r1);
828
769
  } finally {
829
770
  wasm.__wbindgen_add_to_stack_pointer(16);
830
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
771
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
831
772
  }
832
773
  }
833
774
 
834
775
  /**
776
+ * @param {number} width
777
+ * @param {number} height
835
778
  * @returns {string}
836
779
  */
837
- export function svgPatMountains() {
780
+ export function scifiPanelA2(width, height) {
838
781
  let deferred1_0;
839
782
  let deferred1_1;
840
783
  try {
841
784
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
842
- wasm.svgPatMountains(retptr);
785
+ wasm.scifiPanelA2(retptr, width, height);
843
786
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
844
787
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
845
788
  deferred1_0 = r0;
@@ -847,19 +790,22 @@ export function svgPatMountains() {
847
790
  return getStringFromWasm0(r0, r1);
848
791
  } finally {
849
792
  wasm.__wbindgen_add_to_stack_pointer(16);
850
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
793
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
851
794
  }
852
795
  }
853
796
 
854
797
  /**
798
+ * @param {number} width
799
+ * @param {number} height
800
+ * @param {number} twidth
855
801
  * @returns {string}
856
802
  */
857
- export function svgPatRain() {
803
+ export function scifiPanelA3(width, height, twidth) {
858
804
  let deferred1_0;
859
805
  let deferred1_1;
860
806
  try {
861
807
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
862
- wasm.svgPatRain(retptr);
808
+ wasm.scifiPanelA3(retptr, width, height, twidth);
863
809
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
864
810
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
865
811
  deferred1_0 = r0;
@@ -867,19 +813,21 @@ export function svgPatRain() {
867
813
  return getStringFromWasm0(r0, r1);
868
814
  } finally {
869
815
  wasm.__wbindgen_add_to_stack_pointer(16);
870
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
816
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
871
817
  }
872
818
  }
873
819
 
874
820
  /**
821
+ * @param {number} width
822
+ * @param {number} height
875
823
  * @returns {string}
876
824
  */
877
- export function svgPatRectWeavingA() {
825
+ export function scifiPanelB1(width, height) {
878
826
  let deferred1_0;
879
827
  let deferred1_1;
880
828
  try {
881
829
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
882
- wasm.svgPatRectWeavingA(retptr);
830
+ wasm.scifiPanelB1(retptr, width, height);
883
831
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
884
832
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
885
833
  deferred1_0 = r0;
@@ -887,19 +835,21 @@ export function svgPatRectWeavingA() {
887
835
  return getStringFromWasm0(r0, r1);
888
836
  } finally {
889
837
  wasm.__wbindgen_add_to_stack_pointer(16);
890
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
838
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
891
839
  }
892
840
  }
893
841
 
894
842
  /**
843
+ * @param {number} width
844
+ * @param {number} height
895
845
  * @returns {string}
896
846
  */
897
- export function svgPatRectWeavingB() {
847
+ export function scifiPanelB2(width, height) {
898
848
  let deferred1_0;
899
849
  let deferred1_1;
900
850
  try {
901
851
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
902
- wasm.svgPatRectWeavingB(retptr);
852
+ wasm.scifiPanelB2(retptr, width, height);
903
853
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
904
854
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
905
855
  deferred1_0 = r0;
@@ -907,19 +857,21 @@ export function svgPatRectWeavingB() {
907
857
  return getStringFromWasm0(r0, r1);
908
858
  } finally {
909
859
  wasm.__wbindgen_add_to_stack_pointer(16);
910
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
860
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
911
861
  }
912
862
  }
913
863
 
914
864
  /**
865
+ * @param {number} width
866
+ * @param {number} height
915
867
  * @returns {string}
916
868
  */
917
- export function svgPatRectWeavingC() {
869
+ export function scifiPanelB3(width, height) {
918
870
  let deferred1_0;
919
871
  let deferred1_1;
920
872
  try {
921
873
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
922
- wasm.svgPatRectWeavingC(retptr);
874
+ wasm.scifiPanelB3(retptr, width, height);
923
875
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
924
876
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
925
877
  deferred1_0 = r0;
@@ -927,19 +879,21 @@ export function svgPatRectWeavingC() {
927
879
  return getStringFromWasm0(r0, r1);
928
880
  } finally {
929
881
  wasm.__wbindgen_add_to_stack_pointer(16);
930
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
882
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
931
883
  }
932
884
  }
933
885
 
934
886
  /**
887
+ * @param {number} width
888
+ * @param {number} height
935
889
  * @returns {string}
936
890
  */
937
- export function svgPatShellA() {
891
+ export function scifiPanelB4(width, height) {
938
892
  let deferred1_0;
939
893
  let deferred1_1;
940
894
  try {
941
895
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
942
- wasm.svgPatShellA(retptr);
896
+ wasm.scifiPanelB4(retptr, width, height);
943
897
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
944
898
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
945
899
  deferred1_0 = r0;
@@ -947,19 +901,22 @@ export function svgPatShellA() {
947
901
  return getStringFromWasm0(r0, r1);
948
902
  } finally {
949
903
  wasm.__wbindgen_add_to_stack_pointer(16);
950
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
904
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
951
905
  }
952
906
  }
953
907
 
954
908
  /**
909
+ * @param {number} width
910
+ * @param {number} height
911
+ * @param {number} twidth
955
912
  * @returns {string}
956
913
  */
957
- export function svgPatShellB() {
914
+ export function scifiPanelDV1(width, height, twidth) {
958
915
  let deferred1_0;
959
916
  let deferred1_1;
960
917
  try {
961
918
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
962
- wasm.svgPatShellB(retptr);
919
+ wasm.scifiPanelDV1(retptr, width, height, twidth);
963
920
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
964
921
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
965
922
  deferred1_0 = r0;
@@ -967,19 +924,21 @@ export function svgPatShellB() {
967
924
  return getStringFromWasm0(r0, r1);
968
925
  } finally {
969
926
  wasm.__wbindgen_add_to_stack_pointer(16);
970
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
927
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
971
928
  }
972
929
  }
973
930
 
974
931
  /**
932
+ * @param {number} width
933
+ * @param {number} height
975
934
  * @returns {string}
976
935
  */
977
- export function svgPatSlashParallel() {
936
+ export function scifiPanelDV2(width, height) {
978
937
  let deferred1_0;
979
938
  let deferred1_1;
980
939
  try {
981
940
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
982
- wasm.svgPatSlashParallel(retptr);
941
+ wasm.scifiPanelDV2(retptr, width, height);
983
942
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
984
943
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
985
944
  deferred1_0 = r0;
@@ -987,19 +946,21 @@ export function svgPatSlashParallel() {
987
946
  return getStringFromWasm0(r0, r1);
988
947
  } finally {
989
948
  wasm.__wbindgen_add_to_stack_pointer(16);
990
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
949
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
991
950
  }
992
951
  }
993
952
 
994
953
  /**
954
+ * @param {number} width
955
+ * @param {number} height
995
956
  * @returns {string}
996
957
  */
997
- export function svgPatTotem() {
958
+ export function scifiPanelDV3(width, height) {
998
959
  let deferred1_0;
999
960
  let deferred1_1;
1000
961
  try {
1001
962
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1002
- wasm.svgPatTotem(retptr);
963
+ wasm.scifiPanelDV3(retptr, width, height);
1003
964
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1004
965
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1005
966
  deferred1_0 = r0;
@@ -1007,19 +968,21 @@ export function svgPatTotem() {
1007
968
  return getStringFromWasm0(r0, r1);
1008
969
  } finally {
1009
970
  wasm.__wbindgen_add_to_stack_pointer(16);
1010
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
971
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1011
972
  }
1012
973
  }
1013
974
 
1014
975
  /**
976
+ * @param {number} width
977
+ * @param {number} height
1015
978
  * @returns {string}
1016
979
  */
1017
- export function svgPatTriangleA() {
980
+ export function scifiPanelDV4(width, height) {
1018
981
  let deferred1_0;
1019
982
  let deferred1_1;
1020
983
  try {
1021
984
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1022
- wasm.svgPatTriangleA(retptr);
985
+ wasm.scifiPanelDV4(retptr, width, height);
1023
986
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1024
987
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1025
988
  deferred1_0 = r0;
@@ -1027,19 +990,21 @@ export function svgPatTriangleA() {
1027
990
  return getStringFromWasm0(r0, r1);
1028
991
  } finally {
1029
992
  wasm.__wbindgen_add_to_stack_pointer(16);
1030
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
993
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1031
994
  }
1032
995
  }
1033
996
 
1034
997
  /**
998
+ * @param {number} width
999
+ * @param {number} height
1035
1000
  * @returns {string}
1036
1001
  */
1037
- export function svgPatTriangleB() {
1002
+ export function scifiPanelDV5(width, height) {
1038
1003
  let deferred1_0;
1039
1004
  let deferred1_1;
1040
1005
  try {
1041
1006
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1042
- wasm.svgPatTriangleB(retptr);
1007
+ wasm.scifiPanelDV5(retptr, width, height);
1043
1008
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1044
1009
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1045
1010
  deferred1_0 = r0;
@@ -1047,19 +1012,21 @@ export function svgPatTriangleB() {
1047
1012
  return getStringFromWasm0(r0, r1);
1048
1013
  } finally {
1049
1014
  wasm.__wbindgen_add_to_stack_pointer(16);
1050
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1015
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1051
1016
  }
1052
1017
  }
1053
1018
 
1054
1019
  /**
1020
+ * @param {number} width
1021
+ * @param {number} height
1055
1022
  * @returns {string}
1056
1023
  */
1057
- export function svgPatWaveA() {
1024
+ export function scifiPanelDV6(width, height) {
1058
1025
  let deferred1_0;
1059
1026
  let deferred1_1;
1060
1027
  try {
1061
1028
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1062
- wasm.svgPatWaveA(retptr);
1029
+ wasm.scifiPanelDV6(retptr, width, height);
1063
1030
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1064
1031
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1065
1032
  deferred1_0 = r0;
@@ -1067,19 +1034,21 @@ export function svgPatWaveA() {
1067
1034
  return getStringFromWasm0(r0, r1);
1068
1035
  } finally {
1069
1036
  wasm.__wbindgen_add_to_stack_pointer(16);
1070
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1037
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1071
1038
  }
1072
1039
  }
1073
1040
 
1074
1041
  /**
1042
+ * @param {number} width
1043
+ * @param {number} height
1075
1044
  * @returns {string}
1076
1045
  */
1077
- export function svgPatWaveB() {
1046
+ export function scifiPanelDV7(width, height) {
1078
1047
  let deferred1_0;
1079
1048
  let deferred1_1;
1080
1049
  try {
1081
1050
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1082
- wasm.svgPatWaveB(retptr);
1051
+ wasm.scifiPanelDV7(retptr, width, height);
1083
1052
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1084
1053
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1085
1054
  deferred1_0 = r0;
@@ -1087,19 +1056,21 @@ export function svgPatWaveB() {
1087
1056
  return getStringFromWasm0(r0, r1);
1088
1057
  } finally {
1089
1058
  wasm.__wbindgen_add_to_stack_pointer(16);
1090
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1059
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1091
1060
  }
1092
1061
  }
1093
1062
 
1094
1063
  /**
1064
+ * @param {number} width
1065
+ * @param {number} height
1095
1066
  * @returns {string}
1096
1067
  */
1097
- export function svgPatZigzagA() {
1068
+ export function scifiPanelDV8(width, height) {
1098
1069
  let deferred1_0;
1099
1070
  let deferred1_1;
1100
1071
  try {
1101
1072
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1102
- wasm.svgPatZigzagA(retptr);
1073
+ wasm.scifiPanelDV8(retptr, width, height);
1103
1074
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1104
1075
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1105
1076
  deferred1_0 = r0;
@@ -1107,19 +1078,21 @@ export function svgPatZigzagA() {
1107
1078
  return getStringFromWasm0(r0, r1);
1108
1079
  } finally {
1109
1080
  wasm.__wbindgen_add_to_stack_pointer(16);
1110
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1081
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1111
1082
  }
1112
1083
  }
1113
1084
 
1114
1085
  /**
1086
+ * @param {number} width
1087
+ * @param {number} height
1115
1088
  * @returns {string}
1116
1089
  */
1117
- export function svgPatZigzagB() {
1090
+ export function scifiPanelDV9(width, height) {
1118
1091
  let deferred1_0;
1119
1092
  let deferred1_1;
1120
1093
  try {
1121
1094
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1122
- wasm.svgPatZigzagB(retptr);
1095
+ wasm.scifiPanelDV9(retptr, width, height);
1123
1096
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1124
1097
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1125
1098
  deferred1_0 = r0;
@@ -1127,19 +1100,20 @@ export function svgPatZigzagB() {
1127
1100
  return getStringFromWasm0(r0, r1);
1128
1101
  } finally {
1129
1102
  wasm.__wbindgen_add_to_stack_pointer(16);
1130
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1103
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1131
1104
  }
1132
1105
  }
1133
1106
 
1134
1107
  /**
1108
+ * @param {number} width
1135
1109
  * @returns {string}
1136
1110
  */
1137
- export function svgSpinBarsA() {
1111
+ export function scifiPanelTitleA1(width) {
1138
1112
  let deferred1_0;
1139
1113
  let deferred1_1;
1140
1114
  try {
1141
1115
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1142
- wasm.svgSpinBarsA(retptr);
1116
+ wasm.scifiPanelTitleA1(retptr, width);
1143
1117
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1144
1118
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1145
1119
  deferred1_0 = r0;
@@ -1147,19 +1121,19 @@ export function svgSpinBarsA() {
1147
1121
  return getStringFromWasm0(r0, r1);
1148
1122
  } finally {
1149
1123
  wasm.__wbindgen_add_to_stack_pointer(16);
1150
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1124
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1151
1125
  }
1152
1126
  }
1153
1127
 
1154
1128
  /**
1155
1129
  * @returns {string}
1156
1130
  */
1157
- export function svgSpinBarsB() {
1131
+ export function scifiPanelTitleA2() {
1158
1132
  let deferred1_0;
1159
1133
  let deferred1_1;
1160
1134
  try {
1161
1135
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1162
- wasm.svgSpinBarsB(retptr);
1136
+ wasm.scifiPanelTitleA2(retptr);
1163
1137
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1164
1138
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1165
1139
  deferred1_0 = r0;
@@ -1167,19 +1141,19 @@ export function svgSpinBarsB() {
1167
1141
  return getStringFromWasm0(r0, r1);
1168
1142
  } finally {
1169
1143
  wasm.__wbindgen_add_to_stack_pointer(16);
1170
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1144
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1171
1145
  }
1172
1146
  }
1173
1147
 
1174
1148
  /**
1175
1149
  * @returns {string}
1176
1150
  */
1177
- export function svgSpinBarsC() {
1151
+ export function scifiPanelTitleA3() {
1178
1152
  let deferred1_0;
1179
1153
  let deferred1_1;
1180
1154
  try {
1181
1155
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1182
- wasm.svgSpinBarsC(retptr);
1156
+ wasm.scifiPanelTitleA3(retptr);
1183
1157
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1184
1158
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1185
1159
  deferred1_0 = r0;
@@ -1187,19 +1161,28 @@ export function svgSpinBarsC() {
1187
1161
  return getStringFromWasm0(r0, r1);
1188
1162
  } finally {
1189
1163
  wasm.__wbindgen_add_to_stack_pointer(16);
1190
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1164
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1191
1165
  }
1192
1166
  }
1193
1167
 
1168
+ /**
1169
+ * @param {string | null} [lang]
1170
+ */
1171
+ export function setLang(lang) {
1172
+ var ptr0 = isLikeNone(lang) ? 0 : passStringToWasm0(lang, wasm.__wbindgen_export, wasm.__wbindgen_export2);
1173
+ var len0 = WASM_VECTOR_LEN;
1174
+ wasm.setLang(ptr0, len0);
1175
+ }
1176
+
1194
1177
  /**
1195
1178
  * @returns {string}
1196
1179
  */
1197
- export function svgSpinBlocksA() {
1180
+ export function svgPatBlocks() {
1198
1181
  let deferred1_0;
1199
1182
  let deferred1_1;
1200
1183
  try {
1201
1184
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1202
- wasm.svgSpinBlocksA(retptr);
1185
+ wasm.svgPatBlocks(retptr);
1203
1186
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1204
1187
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1205
1188
  deferred1_0 = r0;
@@ -1207,19 +1190,19 @@ export function svgSpinBlocksA() {
1207
1190
  return getStringFromWasm0(r0, r1);
1208
1191
  } finally {
1209
1192
  wasm.__wbindgen_add_to_stack_pointer(16);
1210
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1193
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1211
1194
  }
1212
1195
  }
1213
1196
 
1214
1197
  /**
1215
1198
  * @returns {string}
1216
1199
  */
1217
- export function svgSpinBlocksB() {
1200
+ export function svgPatCircuitDiagram() {
1218
1201
  let deferred1_0;
1219
1202
  let deferred1_1;
1220
1203
  try {
1221
1204
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1222
- wasm.svgSpinBlocksB(retptr);
1205
+ wasm.svgPatCircuitDiagram(retptr);
1223
1206
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1224
1207
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1225
1208
  deferred1_0 = r0;
@@ -1227,19 +1210,19 @@ export function svgSpinBlocksB() {
1227
1210
  return getStringFromWasm0(r0, r1);
1228
1211
  } finally {
1229
1212
  wasm.__wbindgen_add_to_stack_pointer(16);
1230
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1213
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1231
1214
  }
1232
1215
  }
1233
1216
 
1234
1217
  /**
1235
1218
  * @returns {string}
1236
1219
  */
1237
- export function svgSpinBlocksC() {
1220
+ export function svgPatCircularOverlayA() {
1238
1221
  let deferred1_0;
1239
1222
  let deferred1_1;
1240
1223
  try {
1241
1224
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1242
- wasm.svgSpinBlocksC(retptr);
1225
+ wasm.svgPatCircularOverlayA(retptr);
1243
1226
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1244
1227
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1245
1228
  deferred1_0 = r0;
@@ -1247,19 +1230,19 @@ export function svgSpinBlocksC() {
1247
1230
  return getStringFromWasm0(r0, r1);
1248
1231
  } finally {
1249
1232
  wasm.__wbindgen_add_to_stack_pointer(16);
1250
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1233
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1251
1234
  }
1252
1235
  }
1253
1236
 
1254
1237
  /**
1255
1238
  * @returns {string}
1256
1239
  */
1257
- export function svgSpinClock() {
1240
+ export function svgPatCircularOverlayB() {
1258
1241
  let deferred1_0;
1259
1242
  let deferred1_1;
1260
1243
  try {
1261
1244
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1262
- wasm.svgSpinClock(retptr);
1245
+ wasm.svgPatCircularOverlayB(retptr);
1263
1246
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1264
1247
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1265
1248
  deferred1_0 = r0;
@@ -1267,19 +1250,19 @@ export function svgSpinClock() {
1267
1250
  return getStringFromWasm0(r0, r1);
1268
1251
  } finally {
1269
1252
  wasm.__wbindgen_add_to_stack_pointer(16);
1270
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1253
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1271
1254
  }
1272
1255
  }
1273
1256
 
1274
1257
  /**
1275
1258
  * @returns {string}
1276
1259
  */
1277
- export function svgSpinPointA() {
1260
+ export function svgPatContourLine() {
1278
1261
  let deferred1_0;
1279
1262
  let deferred1_1;
1280
1263
  try {
1281
1264
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1282
- wasm.svgSpinPointA(retptr);
1265
+ wasm.svgPatContourLine(retptr);
1283
1266
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1284
1267
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1285
1268
  deferred1_0 = r0;
@@ -1287,19 +1270,19 @@ export function svgSpinPointA() {
1287
1270
  return getStringFromWasm0(r0, r1);
1288
1271
  } finally {
1289
1272
  wasm.__wbindgen_add_to_stack_pointer(16);
1290
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1273
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1291
1274
  }
1292
1275
  }
1293
1276
 
1294
1277
  /**
1295
1278
  * @returns {string}
1296
1279
  */
1297
- export function svgSpinPointB() {
1280
+ export function svgPatCrosshairA() {
1298
1281
  let deferred1_0;
1299
1282
  let deferred1_1;
1300
1283
  try {
1301
1284
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1302
- wasm.svgSpinPointB(retptr);
1285
+ wasm.svgPatCrosshairA(retptr);
1303
1286
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1304
1287
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1305
1288
  deferred1_0 = r0;
@@ -1307,19 +1290,19 @@ export function svgSpinPointB() {
1307
1290
  return getStringFromWasm0(r0, r1);
1308
1291
  } finally {
1309
1292
  wasm.__wbindgen_add_to_stack_pointer(16);
1310
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1293
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1311
1294
  }
1312
1295
  }
1313
1296
 
1314
1297
  /**
1315
1298
  * @returns {string}
1316
1299
  */
1317
- export function svgSpinPointC() {
1300
+ export function svgPatCrosshairB() {
1318
1301
  let deferred1_0;
1319
1302
  let deferred1_1;
1320
1303
  try {
1321
1304
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1322
- wasm.svgSpinPointC(retptr);
1305
+ wasm.svgPatCrosshairB(retptr);
1323
1306
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1324
1307
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1325
1308
  deferred1_0 = r0;
@@ -1327,19 +1310,19 @@ export function svgSpinPointC() {
1327
1310
  return getStringFromWasm0(r0, r1);
1328
1311
  } finally {
1329
1312
  wasm.__wbindgen_add_to_stack_pointer(16);
1330
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1313
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1331
1314
  }
1332
1315
  }
1333
1316
 
1334
1317
  /**
1335
1318
  * @returns {string}
1336
1319
  */
1337
- export function svgSpinPulseDotA() {
1320
+ export function svgPatCubeA() {
1338
1321
  let deferred1_0;
1339
1322
  let deferred1_1;
1340
1323
  try {
1341
1324
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1342
- wasm.svgSpinPulseDotA(retptr);
1325
+ wasm.svgPatCubeA(retptr);
1343
1326
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1344
1327
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1345
1328
  deferred1_0 = r0;
@@ -1347,19 +1330,19 @@ export function svgSpinPulseDotA() {
1347
1330
  return getStringFromWasm0(r0, r1);
1348
1331
  } finally {
1349
1332
  wasm.__wbindgen_add_to_stack_pointer(16);
1350
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1333
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1351
1334
  }
1352
1335
  }
1353
1336
 
1354
1337
  /**
1355
1338
  * @returns {string}
1356
1339
  */
1357
- export function svgSpinPulseDotB() {
1340
+ export function svgPatCubeB() {
1358
1341
  let deferred1_0;
1359
1342
  let deferred1_1;
1360
1343
  try {
1361
1344
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1362
- wasm.svgSpinPulseDotB(retptr);
1345
+ wasm.svgPatCubeB(retptr);
1363
1346
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1364
1347
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1365
1348
  deferred1_0 = r0;
@@ -1367,19 +1350,19 @@ export function svgSpinPulseDotB() {
1367
1350
  return getStringFromWasm0(r0, r1);
1368
1351
  } finally {
1369
1352
  wasm.__wbindgen_add_to_stack_pointer(16);
1370
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1353
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1371
1354
  }
1372
1355
  }
1373
1356
 
1374
1357
  /**
1375
1358
  * @returns {string}
1376
1359
  */
1377
- export function svgSpinPulseDotC() {
1360
+ export function svgPatCubeC() {
1378
1361
  let deferred1_0;
1379
1362
  let deferred1_1;
1380
1363
  try {
1381
1364
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1382
- wasm.svgSpinPulseDotC(retptr);
1365
+ wasm.svgPatCubeC(retptr);
1383
1366
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1384
1367
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1385
1368
  deferred1_0 = r0;
@@ -1387,19 +1370,19 @@ export function svgSpinPulseDotC() {
1387
1370
  return getStringFromWasm0(r0, r1);
1388
1371
  } finally {
1389
1372
  wasm.__wbindgen_add_to_stack_pointer(16);
1390
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1373
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1391
1374
  }
1392
1375
  }
1393
1376
 
1394
1377
  /**
1395
1378
  * @returns {string}
1396
1379
  */
1397
- export function svgSpinPulseRingA() {
1380
+ export function svgPatDiamondFlipped() {
1398
1381
  let deferred1_0;
1399
1382
  let deferred1_1;
1400
1383
  try {
1401
1384
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1402
- wasm.svgSpinPulseRingA(retptr);
1385
+ wasm.svgPatDiamondFlipped(retptr);
1403
1386
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1404
1387
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1405
1388
  deferred1_0 = r0;
@@ -1407,19 +1390,19 @@ export function svgSpinPulseRingA() {
1407
1390
  return getStringFromWasm0(r0, r1);
1408
1391
  } finally {
1409
1392
  wasm.__wbindgen_add_to_stack_pointer(16);
1410
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1393
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1411
1394
  }
1412
1395
  }
1413
1396
 
1414
1397
  /**
1415
1398
  * @returns {string}
1416
1399
  */
1417
- export function svgSpinPulseRingB() {
1400
+ export function svgPatDiamondLattice() {
1418
1401
  let deferred1_0;
1419
1402
  let deferred1_1;
1420
1403
  try {
1421
1404
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1422
- wasm.svgSpinPulseRingB(retptr);
1405
+ wasm.svgPatDiamondLattice(retptr);
1423
1406
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1424
1407
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1425
1408
  deferred1_0 = r0;
@@ -1427,19 +1410,19 @@ export function svgSpinPulseRingB() {
1427
1410
  return getStringFromWasm0(r0, r1);
1428
1411
  } finally {
1429
1412
  wasm.__wbindgen_add_to_stack_pointer(16);
1430
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1413
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1431
1414
  }
1432
1415
  }
1433
1416
 
1434
1417
  /**
1435
1418
  * @returns {string}
1436
1419
  */
1437
- export function svgSpinPulseRingC() {
1420
+ export function svgPatDiamondPixel() {
1438
1421
  let deferred1_0;
1439
1422
  let deferred1_1;
1440
1423
  try {
1441
1424
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1442
- wasm.svgSpinPulseRingC(retptr);
1425
+ wasm.svgPatDiamondPixel(retptr);
1443
1426
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1444
1427
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1445
1428
  deferred1_0 = r0;
@@ -1447,19 +1430,19 @@ export function svgSpinPulseRingC() {
1447
1430
  return getStringFromWasm0(r0, r1);
1448
1431
  } finally {
1449
1432
  wasm.__wbindgen_add_to_stack_pointer(16);
1450
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1433
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1451
1434
  }
1452
1435
  }
1453
1436
 
1454
1437
  /**
1455
1438
  * @returns {string}
1456
1439
  */
1457
- export function svgSpinRingA() {
1440
+ export function svgPatDiamondWeaving() {
1458
1441
  let deferred1_0;
1459
1442
  let deferred1_1;
1460
1443
  try {
1461
1444
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1462
- wasm.svgSpinRingA(retptr);
1445
+ wasm.svgPatDiamondWeaving(retptr);
1463
1446
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1464
1447
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1465
1448
  deferred1_0 = r0;
@@ -1467,19 +1450,19 @@ export function svgSpinRingA() {
1467
1450
  return getStringFromWasm0(r0, r1);
1468
1451
  } finally {
1469
1452
  wasm.__wbindgen_add_to_stack_pointer(16);
1470
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1453
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1471
1454
  }
1472
1455
  }
1473
1456
 
1474
1457
  /**
1475
1458
  * @returns {string}
1476
1459
  */
1477
- export function svgSpinRingB() {
1460
+ export function svgPatDots() {
1478
1461
  let deferred1_0;
1479
1462
  let deferred1_1;
1480
1463
  try {
1481
1464
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1482
- wasm.svgSpinRingB(retptr);
1465
+ wasm.svgPatDots(retptr);
1483
1466
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1484
1467
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1485
1468
  deferred1_0 = r0;
@@ -1487,19 +1470,19 @@ export function svgSpinRingB() {
1487
1470
  return getStringFromWasm0(r0, r1);
1488
1471
  } finally {
1489
1472
  wasm.__wbindgen_add_to_stack_pointer(16);
1490
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1473
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1491
1474
  }
1492
1475
  }
1493
1476
 
1494
1477
  /**
1495
1478
  * @returns {string}
1496
1479
  */
1497
- export function svgSpinRingC() {
1480
+ export function svgPatHexagonA() {
1498
1481
  let deferred1_0;
1499
1482
  let deferred1_1;
1500
1483
  try {
1501
1484
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1502
- wasm.svgSpinRingC(retptr);
1485
+ wasm.svgPatHexagonA(retptr);
1503
1486
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1504
1487
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1505
1488
  deferred1_0 = r0;
@@ -1507,20 +1490,19 @@ export function svgSpinRingC() {
1507
1490
  return getStringFromWasm0(r0, r1);
1508
1491
  } finally {
1509
1492
  wasm.__wbindgen_add_to_stack_pointer(16);
1510
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1493
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1511
1494
  }
1512
1495
  }
1513
1496
 
1514
1497
  /**
1515
- * @param {number} width
1516
1498
  * @returns {string}
1517
1499
  */
1518
- export function scifiButtonA1(width) {
1500
+ export function svgPatHexagonB() {
1519
1501
  let deferred1_0;
1520
1502
  let deferred1_1;
1521
1503
  try {
1522
1504
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1523
- wasm.scifiButtonA1(retptr, width);
1505
+ wasm.svgPatHexagonB(retptr);
1524
1506
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1525
1507
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1526
1508
  deferred1_0 = r0;
@@ -1528,20 +1510,19 @@ export function scifiButtonA1(width) {
1528
1510
  return getStringFromWasm0(r0, r1);
1529
1511
  } finally {
1530
1512
  wasm.__wbindgen_add_to_stack_pointer(16);
1531
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1513
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1532
1514
  }
1533
1515
  }
1534
1516
 
1535
1517
  /**
1536
- * @param {number} width
1537
1518
  * @returns {string}
1538
1519
  */
1539
- export function scifiButtonA2(width) {
1520
+ export function svgPatHexagonC() {
1540
1521
  let deferred1_0;
1541
1522
  let deferred1_1;
1542
1523
  try {
1543
1524
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1544
- wasm.scifiButtonA2(retptr, width);
1525
+ wasm.svgPatHexagonC(retptr);
1545
1526
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1546
1527
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1547
1528
  deferred1_0 = r0;
@@ -1549,20 +1530,19 @@ export function scifiButtonA2(width) {
1549
1530
  return getStringFromWasm0(r0, r1);
1550
1531
  } finally {
1551
1532
  wasm.__wbindgen_add_to_stack_pointer(16);
1552
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1533
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1553
1534
  }
1554
1535
  }
1555
1536
 
1556
1537
  /**
1557
- * @param {number} width
1558
1538
  * @returns {string}
1559
1539
  */
1560
- export function scifiButtonA3(width) {
1540
+ export function svgPatHexagonCurved() {
1561
1541
  let deferred1_0;
1562
1542
  let deferred1_1;
1563
1543
  try {
1564
1544
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1565
- wasm.scifiButtonA3(retptr, width);
1545
+ wasm.svgPatHexagonCurved(retptr);
1566
1546
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1567
1547
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1568
1548
  deferred1_0 = r0;
@@ -1570,20 +1550,19 @@ export function scifiButtonA3(width) {
1570
1550
  return getStringFromWasm0(r0, r1);
1571
1551
  } finally {
1572
1552
  wasm.__wbindgen_add_to_stack_pointer(16);
1573
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1553
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1574
1554
  }
1575
1555
  }
1576
1556
 
1577
1557
  /**
1578
- * @param {number} width
1579
1558
  * @returns {string}
1580
1559
  */
1581
- export function scifiButtonA4(width) {
1560
+ export function svgPatHexagonD() {
1582
1561
  let deferred1_0;
1583
1562
  let deferred1_1;
1584
1563
  try {
1585
1564
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1586
- wasm.scifiButtonA4(retptr, width);
1565
+ wasm.svgPatHexagonD(retptr);
1587
1566
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1588
1567
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1589
1568
  deferred1_0 = r0;
@@ -1591,20 +1570,19 @@ export function scifiButtonA4(width) {
1591
1570
  return getStringFromWasm0(r0, r1);
1592
1571
  } finally {
1593
1572
  wasm.__wbindgen_add_to_stack_pointer(16);
1594
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1573
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1595
1574
  }
1596
1575
  }
1597
1576
 
1598
1577
  /**
1599
- * @param {number} width
1600
1578
  * @returns {string}
1601
1579
  */
1602
- export function scifiButtonA5(width) {
1580
+ export function svgPatLineGrid() {
1603
1581
  let deferred1_0;
1604
1582
  let deferred1_1;
1605
1583
  try {
1606
1584
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1607
- wasm.scifiButtonA5(retptr, width);
1585
+ wasm.svgPatLineGrid(retptr);
1608
1586
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1609
1587
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1610
1588
  deferred1_0 = r0;
@@ -1612,19 +1590,19 @@ export function scifiButtonA5(width) {
1612
1590
  return getStringFromWasm0(r0, r1);
1613
1591
  } finally {
1614
1592
  wasm.__wbindgen_add_to_stack_pointer(16);
1615
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1593
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1616
1594
  }
1617
1595
  }
1618
1596
 
1619
1597
  /**
1620
1598
  * @returns {string}
1621
1599
  */
1622
- export function scifiDecoA1() {
1600
+ export function svgPatLineWeaving() {
1623
1601
  let deferred1_0;
1624
1602
  let deferred1_1;
1625
1603
  try {
1626
1604
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1627
- wasm.scifiDecoA1(retptr);
1605
+ wasm.svgPatLineWeaving(retptr);
1628
1606
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1629
1607
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1630
1608
  deferred1_0 = r0;
@@ -1632,19 +1610,19 @@ export function scifiDecoA1() {
1632
1610
  return getStringFromWasm0(r0, r1);
1633
1611
  } finally {
1634
1612
  wasm.__wbindgen_add_to_stack_pointer(16);
1635
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1613
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1636
1614
  }
1637
1615
  }
1638
1616
 
1639
1617
  /**
1640
1618
  * @returns {string}
1641
1619
  */
1642
- export function scifiDecoB1() {
1620
+ export function svgPatMazeA() {
1643
1621
  let deferred1_0;
1644
1622
  let deferred1_1;
1645
1623
  try {
1646
1624
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1647
- wasm.scifiDecoB1(retptr);
1625
+ wasm.svgPatMazeA(retptr);
1648
1626
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1649
1627
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1650
1628
  deferred1_0 = r0;
@@ -1652,19 +1630,19 @@ export function scifiDecoB1() {
1652
1630
  return getStringFromWasm0(r0, r1);
1653
1631
  } finally {
1654
1632
  wasm.__wbindgen_add_to_stack_pointer(16);
1655
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1633
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1656
1634
  }
1657
1635
  }
1658
1636
 
1659
1637
  /**
1660
1638
  * @returns {string}
1661
1639
  */
1662
- export function scifiDecoB2() {
1640
+ export function svgPatMazeB() {
1663
1641
  let deferred1_0;
1664
1642
  let deferred1_1;
1665
1643
  try {
1666
1644
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1667
- wasm.scifiDecoB2(retptr);
1645
+ wasm.svgPatMazeB(retptr);
1668
1646
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1669
1647
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1670
1648
  deferred1_0 = r0;
@@ -1672,19 +1650,19 @@ export function scifiDecoB2() {
1672
1650
  return getStringFromWasm0(r0, r1);
1673
1651
  } finally {
1674
1652
  wasm.__wbindgen_add_to_stack_pointer(16);
1675
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1653
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1676
1654
  }
1677
1655
  }
1678
1656
 
1679
1657
  /**
1680
1658
  * @returns {string}
1681
1659
  */
1682
- export function scifiDecoB3() {
1660
+ export function svgPatMazeC() {
1683
1661
  let deferred1_0;
1684
1662
  let deferred1_1;
1685
1663
  try {
1686
1664
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1687
- wasm.scifiDecoB3(retptr);
1665
+ wasm.svgPatMazeC(retptr);
1688
1666
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1689
1667
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1690
1668
  deferred1_0 = r0;
@@ -1692,19 +1670,19 @@ export function scifiDecoB3() {
1692
1670
  return getStringFromWasm0(r0, r1);
1693
1671
  } finally {
1694
1672
  wasm.__wbindgen_add_to_stack_pointer(16);
1695
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1673
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1696
1674
  }
1697
1675
  }
1698
1676
 
1699
1677
  /**
1700
1678
  * @returns {string}
1701
1679
  */
1702
- export function scifiDecoD1() {
1680
+ export function svgPatMountains() {
1703
1681
  let deferred1_0;
1704
1682
  let deferred1_1;
1705
1683
  try {
1706
1684
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1707
- wasm.scifiDecoD1(retptr);
1685
+ wasm.svgPatMountains(retptr);
1708
1686
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1709
1687
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1710
1688
  deferred1_0 = r0;
@@ -1712,21 +1690,19 @@ export function scifiDecoD1() {
1712
1690
  return getStringFromWasm0(r0, r1);
1713
1691
  } finally {
1714
1692
  wasm.__wbindgen_add_to_stack_pointer(16);
1715
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1693
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1716
1694
  }
1717
1695
  }
1718
1696
 
1719
1697
  /**
1720
- * @param {number} width
1721
- * @param {number} height
1722
1698
  * @returns {string}
1723
1699
  */
1724
- export function scifiGeomHexagon(width, height) {
1700
+ export function svgPatRain() {
1725
1701
  let deferred1_0;
1726
1702
  let deferred1_1;
1727
1703
  try {
1728
1704
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1729
- wasm.scifiGeomHexagon(retptr, width, height);
1705
+ wasm.svgPatRain(retptr);
1730
1706
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1731
1707
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1732
1708
  deferred1_0 = r0;
@@ -1734,21 +1710,19 @@ export function scifiGeomHexagon(width, height) {
1734
1710
  return getStringFromWasm0(r0, r1);
1735
1711
  } finally {
1736
1712
  wasm.__wbindgen_add_to_stack_pointer(16);
1737
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1713
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1738
1714
  }
1739
1715
  }
1740
1716
 
1741
1717
  /**
1742
- * @param {number} width
1743
- * @param {number} height
1744
1718
  * @returns {string}
1745
1719
  */
1746
- export function scifiGeomeParallelogram(width, height) {
1720
+ export function svgPatRectWeavingA() {
1747
1721
  let deferred1_0;
1748
1722
  let deferred1_1;
1749
1723
  try {
1750
1724
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1751
- wasm.scifiGeomeParallelogram(retptr, width, height);
1725
+ wasm.svgPatRectWeavingA(retptr);
1752
1726
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1753
1727
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1754
1728
  deferred1_0 = r0;
@@ -1756,21 +1730,19 @@ export function scifiGeomeParallelogram(width, height) {
1756
1730
  return getStringFromWasm0(r0, r1);
1757
1731
  } finally {
1758
1732
  wasm.__wbindgen_add_to_stack_pointer(16);
1759
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1733
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1760
1734
  }
1761
1735
  }
1762
1736
 
1763
1737
  /**
1764
- * @param {number} width
1765
- * @param {number} height
1766
1738
  * @returns {string}
1767
1739
  */
1768
- export function scifiGeomeRectangle(width, height) {
1740
+ export function svgPatRectWeavingB() {
1769
1741
  let deferred1_0;
1770
1742
  let deferred1_1;
1771
1743
  try {
1772
1744
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1773
- wasm.scifiGeomeRectangle(retptr, width, height);
1745
+ wasm.svgPatRectWeavingB(retptr);
1774
1746
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1775
1747
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1776
1748
  deferred1_0 = r0;
@@ -1778,21 +1750,19 @@ export function scifiGeomeRectangle(width, height) {
1778
1750
  return getStringFromWasm0(r0, r1);
1779
1751
  } finally {
1780
1752
  wasm.__wbindgen_add_to_stack_pointer(16);
1781
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1753
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1782
1754
  }
1783
1755
  }
1784
1756
 
1785
1757
  /**
1786
- * @param {number} width
1787
- * @param {number} height
1788
1758
  * @returns {string}
1789
1759
  */
1790
- export function scifiGeomeTrapezoid(width, height) {
1760
+ export function svgPatRectWeavingC() {
1791
1761
  let deferred1_0;
1792
1762
  let deferred1_1;
1793
1763
  try {
1794
1764
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1795
- wasm.scifiGeomeTrapezoid(retptr, width, height);
1765
+ wasm.svgPatRectWeavingC(retptr);
1796
1766
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1797
1767
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1798
1768
  deferred1_0 = r0;
@@ -1800,21 +1770,19 @@ export function scifiGeomeTrapezoid(width, height) {
1800
1770
  return getStringFromWasm0(r0, r1);
1801
1771
  } finally {
1802
1772
  wasm.__wbindgen_add_to_stack_pointer(16);
1803
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1773
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1804
1774
  }
1805
1775
  }
1806
1776
 
1807
1777
  /**
1808
- * @param {number} width
1809
- * @param {number} height
1810
1778
  * @returns {string}
1811
1779
  */
1812
- export function scifiGeomeTriangle(width, height) {
1780
+ export function svgPatShellA() {
1813
1781
  let deferred1_0;
1814
1782
  let deferred1_1;
1815
1783
  try {
1816
1784
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1817
- wasm.scifiGeomeTriangle(retptr, width, height);
1785
+ wasm.svgPatShellA(retptr);
1818
1786
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1819
1787
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1820
1788
  deferred1_0 = r0;
@@ -1822,20 +1790,19 @@ export function scifiGeomeTriangle(width, height) {
1822
1790
  return getStringFromWasm0(r0, r1);
1823
1791
  } finally {
1824
1792
  wasm.__wbindgen_add_to_stack_pointer(16);
1825
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1793
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1826
1794
  }
1827
1795
  }
1828
1796
 
1829
1797
  /**
1830
- * @param {number} width
1831
1798
  * @returns {string}
1832
1799
  */
1833
- export function scifiHeaderA1(width) {
1800
+ export function svgPatShellB() {
1834
1801
  let deferred1_0;
1835
1802
  let deferred1_1;
1836
1803
  try {
1837
1804
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1838
- wasm.scifiHeaderA1(retptr, width);
1805
+ wasm.svgPatShellB(retptr);
1839
1806
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1840
1807
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1841
1808
  deferred1_0 = r0;
@@ -1843,20 +1810,19 @@ export function scifiHeaderA1(width) {
1843
1810
  return getStringFromWasm0(r0, r1);
1844
1811
  } finally {
1845
1812
  wasm.__wbindgen_add_to_stack_pointer(16);
1846
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1813
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1847
1814
  }
1848
1815
  }
1849
1816
 
1850
1817
  /**
1851
- * @param {number} width
1852
1818
  * @returns {string}
1853
1819
  */
1854
- export function scifiHeaderA2(width) {
1820
+ export function svgPatSlashParallel() {
1855
1821
  let deferred1_0;
1856
1822
  let deferred1_1;
1857
1823
  try {
1858
1824
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1859
- wasm.scifiHeaderA2(retptr, width);
1825
+ wasm.svgPatSlashParallel(retptr);
1860
1826
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1861
1827
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1862
1828
  deferred1_0 = r0;
@@ -1864,20 +1830,19 @@ export function scifiHeaderA2(width) {
1864
1830
  return getStringFromWasm0(r0, r1);
1865
1831
  } finally {
1866
1832
  wasm.__wbindgen_add_to_stack_pointer(16);
1867
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1833
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1868
1834
  }
1869
1835
  }
1870
1836
 
1871
1837
  /**
1872
- * @param {number} width
1873
1838
  * @returns {string}
1874
1839
  */
1875
- export function scifiHeaderA3(width) {
1840
+ export function svgPatTest() {
1876
1841
  let deferred1_0;
1877
1842
  let deferred1_1;
1878
1843
  try {
1879
1844
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1880
- wasm.scifiHeaderA3(retptr, width);
1845
+ wasm.svgPatTest(retptr);
1881
1846
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1882
1847
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1883
1848
  deferred1_0 = r0;
@@ -1885,20 +1850,19 @@ export function scifiHeaderA3(width) {
1885
1850
  return getStringFromWasm0(r0, r1);
1886
1851
  } finally {
1887
1852
  wasm.__wbindgen_add_to_stack_pointer(16);
1888
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1853
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1889
1854
  }
1890
1855
  }
1891
1856
 
1892
1857
  /**
1893
- * @param {number} width
1894
1858
  * @returns {string}
1895
1859
  */
1896
- export function scifiHeaderA4(width) {
1860
+ export function svgPatTotem() {
1897
1861
  let deferred1_0;
1898
1862
  let deferred1_1;
1899
1863
  try {
1900
1864
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1901
- wasm.scifiHeaderA4(retptr, width);
1865
+ wasm.svgPatTotem(retptr);
1902
1866
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1903
1867
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1904
1868
  deferred1_0 = r0;
@@ -1906,20 +1870,19 @@ export function scifiHeaderA4(width) {
1906
1870
  return getStringFromWasm0(r0, r1);
1907
1871
  } finally {
1908
1872
  wasm.__wbindgen_add_to_stack_pointer(16);
1909
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1873
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1910
1874
  }
1911
1875
  }
1912
1876
 
1913
1877
  /**
1914
- * @param {number} width
1915
1878
  * @returns {string}
1916
1879
  */
1917
- export function scifiPanelTitleA1(width) {
1880
+ export function svgPatTriangleA() {
1918
1881
  let deferred1_0;
1919
1882
  let deferred1_1;
1920
1883
  try {
1921
1884
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1922
- wasm.scifiPanelTitleA1(retptr, width);
1885
+ wasm.svgPatTriangleA(retptr);
1923
1886
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1924
1887
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1925
1888
  deferred1_0 = r0;
@@ -1927,19 +1890,19 @@ export function scifiPanelTitleA1(width) {
1927
1890
  return getStringFromWasm0(r0, r1);
1928
1891
  } finally {
1929
1892
  wasm.__wbindgen_add_to_stack_pointer(16);
1930
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1893
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1931
1894
  }
1932
1895
  }
1933
1896
 
1934
1897
  /**
1935
1898
  * @returns {string}
1936
1899
  */
1937
- export function scifiPanelTitleA2() {
1900
+ export function svgPatTriangleB() {
1938
1901
  let deferred1_0;
1939
1902
  let deferred1_1;
1940
1903
  try {
1941
1904
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1942
- wasm.scifiPanelTitleA2(retptr);
1905
+ wasm.svgPatTriangleB(retptr);
1943
1906
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1944
1907
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1945
1908
  deferred1_0 = r0;
@@ -1947,19 +1910,19 @@ export function scifiPanelTitleA2() {
1947
1910
  return getStringFromWasm0(r0, r1);
1948
1911
  } finally {
1949
1912
  wasm.__wbindgen_add_to_stack_pointer(16);
1950
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1913
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1951
1914
  }
1952
1915
  }
1953
1916
 
1954
1917
  /**
1955
1918
  * @returns {string}
1956
1919
  */
1957
- export function scifiPanelTitleA3() {
1920
+ export function svgPatWaveA() {
1958
1921
  let deferred1_0;
1959
1922
  let deferred1_1;
1960
1923
  try {
1961
1924
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1962
- wasm.scifiPanelTitleA3(retptr);
1925
+ wasm.svgPatWaveA(retptr);
1963
1926
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1964
1927
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1965
1928
  deferred1_0 = r0;
@@ -1967,22 +1930,19 @@ export function scifiPanelTitleA3() {
1967
1930
  return getStringFromWasm0(r0, r1);
1968
1931
  } finally {
1969
1932
  wasm.__wbindgen_add_to_stack_pointer(16);
1970
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1933
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1971
1934
  }
1972
1935
  }
1973
1936
 
1974
1937
  /**
1975
- * @param {number} width
1976
- * @param {number} height
1977
- * @param {number} twidth
1978
1938
  * @returns {string}
1979
1939
  */
1980
- export function scifiPanelA1(width, height, twidth) {
1940
+ export function svgPatWaveB() {
1981
1941
  let deferred1_0;
1982
1942
  let deferred1_1;
1983
1943
  try {
1984
1944
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
1985
- wasm.scifiPanelA1(retptr, width, height, twidth);
1945
+ wasm.svgPatWaveB(retptr);
1986
1946
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
1987
1947
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
1988
1948
  deferred1_0 = r0;
@@ -1990,21 +1950,19 @@ export function scifiPanelA1(width, height, twidth) {
1990
1950
  return getStringFromWasm0(r0, r1);
1991
1951
  } finally {
1992
1952
  wasm.__wbindgen_add_to_stack_pointer(16);
1993
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1953
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
1994
1954
  }
1995
1955
  }
1996
1956
 
1997
1957
  /**
1998
- * @param {number} width
1999
- * @param {number} height
2000
1958
  * @returns {string}
2001
1959
  */
2002
- export function scifiPanelA2(width, height) {
1960
+ export function svgPatZigzagA() {
2003
1961
  let deferred1_0;
2004
1962
  let deferred1_1;
2005
1963
  try {
2006
1964
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2007
- wasm.scifiPanelA2(retptr, width, height);
1965
+ wasm.svgPatZigzagA(retptr);
2008
1966
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2009
1967
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2010
1968
  deferred1_0 = r0;
@@ -2012,22 +1970,19 @@ export function scifiPanelA2(width, height) {
2012
1970
  return getStringFromWasm0(r0, r1);
2013
1971
  } finally {
2014
1972
  wasm.__wbindgen_add_to_stack_pointer(16);
2015
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1973
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2016
1974
  }
2017
1975
  }
2018
1976
 
2019
1977
  /**
2020
- * @param {number} width
2021
- * @param {number} height
2022
- * @param {number} twidth
2023
1978
  * @returns {string}
2024
1979
  */
2025
- export function scifiPanelA3(width, height, twidth) {
1980
+ export function svgPatZigzagB() {
2026
1981
  let deferred1_0;
2027
1982
  let deferred1_1;
2028
1983
  try {
2029
1984
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2030
- wasm.scifiPanelA3(retptr, width, height, twidth);
1985
+ wasm.svgPatZigzagB(retptr);
2031
1986
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2032
1987
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2033
1988
  deferred1_0 = r0;
@@ -2035,21 +1990,19 @@ export function scifiPanelA3(width, height, twidth) {
2035
1990
  return getStringFromWasm0(r0, r1);
2036
1991
  } finally {
2037
1992
  wasm.__wbindgen_add_to_stack_pointer(16);
2038
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
1993
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2039
1994
  }
2040
1995
  }
2041
1996
 
2042
1997
  /**
2043
- * @param {number} width
2044
- * @param {number} height
2045
1998
  * @returns {string}
2046
1999
  */
2047
- export function scifiPanelB1(width, height) {
2000
+ export function svgSpinBarsA() {
2048
2001
  let deferred1_0;
2049
2002
  let deferred1_1;
2050
2003
  try {
2051
2004
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2052
- wasm.scifiPanelB1(retptr, width, height);
2005
+ wasm.svgSpinBarsA(retptr);
2053
2006
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2054
2007
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2055
2008
  deferred1_0 = r0;
@@ -2057,21 +2010,19 @@ export function scifiPanelB1(width, height) {
2057
2010
  return getStringFromWasm0(r0, r1);
2058
2011
  } finally {
2059
2012
  wasm.__wbindgen_add_to_stack_pointer(16);
2060
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2013
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2061
2014
  }
2062
2015
  }
2063
2016
 
2064
2017
  /**
2065
- * @param {number} width
2066
- * @param {number} height
2067
2018
  * @returns {string}
2068
2019
  */
2069
- export function scifiPanelB2(width, height) {
2020
+ export function svgSpinBarsB() {
2070
2021
  let deferred1_0;
2071
2022
  let deferred1_1;
2072
2023
  try {
2073
2024
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2074
- wasm.scifiPanelB2(retptr, width, height);
2025
+ wasm.svgSpinBarsB(retptr);
2075
2026
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2076
2027
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2077
2028
  deferred1_0 = r0;
@@ -2079,21 +2030,19 @@ export function scifiPanelB2(width, height) {
2079
2030
  return getStringFromWasm0(r0, r1);
2080
2031
  } finally {
2081
2032
  wasm.__wbindgen_add_to_stack_pointer(16);
2082
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2033
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2083
2034
  }
2084
2035
  }
2085
2036
 
2086
2037
  /**
2087
- * @param {number} width
2088
- * @param {number} height
2089
2038
  * @returns {string}
2090
2039
  */
2091
- export function scifiPanelB3(width, height) {
2040
+ export function svgSpinBarsC() {
2092
2041
  let deferred1_0;
2093
2042
  let deferred1_1;
2094
2043
  try {
2095
2044
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2096
- wasm.scifiPanelB3(retptr, width, height);
2045
+ wasm.svgSpinBarsC(retptr);
2097
2046
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2098
2047
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2099
2048
  deferred1_0 = r0;
@@ -2101,21 +2050,19 @@ export function scifiPanelB3(width, height) {
2101
2050
  return getStringFromWasm0(r0, r1);
2102
2051
  } finally {
2103
2052
  wasm.__wbindgen_add_to_stack_pointer(16);
2104
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2053
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2105
2054
  }
2106
2055
  }
2107
2056
 
2108
2057
  /**
2109
- * @param {number} width
2110
- * @param {number} height
2111
2058
  * @returns {string}
2112
2059
  */
2113
- export function scifiPanelB4(width, height) {
2060
+ export function svgSpinBlocksA() {
2114
2061
  let deferred1_0;
2115
2062
  let deferred1_1;
2116
2063
  try {
2117
2064
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2118
- wasm.scifiPanelB4(retptr, width, height);
2065
+ wasm.svgSpinBlocksA(retptr);
2119
2066
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2120
2067
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2121
2068
  deferred1_0 = r0;
@@ -2123,22 +2070,19 @@ export function scifiPanelB4(width, height) {
2123
2070
  return getStringFromWasm0(r0, r1);
2124
2071
  } finally {
2125
2072
  wasm.__wbindgen_add_to_stack_pointer(16);
2126
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2073
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2127
2074
  }
2128
2075
  }
2129
2076
 
2130
2077
  /**
2131
- * @param {number} width
2132
- * @param {number} height
2133
- * @param {number} twidth
2134
2078
  * @returns {string}
2135
2079
  */
2136
- export function scifiPanelDV1(width, height, twidth) {
2080
+ export function svgSpinBlocksB() {
2137
2081
  let deferred1_0;
2138
2082
  let deferred1_1;
2139
2083
  try {
2140
2084
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2141
- wasm.scifiPanelDV1(retptr, width, height, twidth);
2085
+ wasm.svgSpinBlocksB(retptr);
2142
2086
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2143
2087
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2144
2088
  deferred1_0 = r0;
@@ -2146,21 +2090,19 @@ export function scifiPanelDV1(width, height, twidth) {
2146
2090
  return getStringFromWasm0(r0, r1);
2147
2091
  } finally {
2148
2092
  wasm.__wbindgen_add_to_stack_pointer(16);
2149
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2093
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2150
2094
  }
2151
2095
  }
2152
2096
 
2153
2097
  /**
2154
- * @param {number} width
2155
- * @param {number} height
2156
2098
  * @returns {string}
2157
2099
  */
2158
- export function scifiPanelDV2(width, height) {
2100
+ export function svgSpinBlocksC() {
2159
2101
  let deferred1_0;
2160
2102
  let deferred1_1;
2161
2103
  try {
2162
2104
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2163
- wasm.scifiPanelDV2(retptr, width, height);
2105
+ wasm.svgSpinBlocksC(retptr);
2164
2106
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2165
2107
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2166
2108
  deferred1_0 = r0;
@@ -2168,21 +2110,19 @@ export function scifiPanelDV2(width, height) {
2168
2110
  return getStringFromWasm0(r0, r1);
2169
2111
  } finally {
2170
2112
  wasm.__wbindgen_add_to_stack_pointer(16);
2171
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2113
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2172
2114
  }
2173
2115
  }
2174
2116
 
2175
2117
  /**
2176
- * @param {number} width
2177
- * @param {number} height
2178
2118
  * @returns {string}
2179
2119
  */
2180
- export function scifiPanelDV3(width, height) {
2120
+ export function svgSpinClock() {
2181
2121
  let deferred1_0;
2182
2122
  let deferred1_1;
2183
2123
  try {
2184
2124
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2185
- wasm.scifiPanelDV3(retptr, width, height);
2125
+ wasm.svgSpinClock(retptr);
2186
2126
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2187
2127
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2188
2128
  deferred1_0 = r0;
@@ -2190,21 +2130,19 @@ export function scifiPanelDV3(width, height) {
2190
2130
  return getStringFromWasm0(r0, r1);
2191
2131
  } finally {
2192
2132
  wasm.__wbindgen_add_to_stack_pointer(16);
2193
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2133
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2194
2134
  }
2195
2135
  }
2196
2136
 
2197
2137
  /**
2198
- * @param {number} width
2199
- * @param {number} height
2200
2138
  * @returns {string}
2201
2139
  */
2202
- export function scifiPanelDV4(width, height) {
2140
+ export function svgSpinPointA() {
2203
2141
  let deferred1_0;
2204
2142
  let deferred1_1;
2205
2143
  try {
2206
2144
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2207
- wasm.scifiPanelDV4(retptr, width, height);
2145
+ wasm.svgSpinPointA(retptr);
2208
2146
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2209
2147
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2210
2148
  deferred1_0 = r0;
@@ -2212,21 +2150,19 @@ export function scifiPanelDV4(width, height) {
2212
2150
  return getStringFromWasm0(r0, r1);
2213
2151
  } finally {
2214
2152
  wasm.__wbindgen_add_to_stack_pointer(16);
2215
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2153
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2216
2154
  }
2217
2155
  }
2218
2156
 
2219
2157
  /**
2220
- * @param {number} width
2221
- * @param {number} height
2222
2158
  * @returns {string}
2223
2159
  */
2224
- export function scifiPanelDV5(width, height) {
2160
+ export function svgSpinPointB() {
2225
2161
  let deferred1_0;
2226
2162
  let deferred1_1;
2227
2163
  try {
2228
2164
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2229
- wasm.scifiPanelDV5(retptr, width, height);
2165
+ wasm.svgSpinPointB(retptr);
2230
2166
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2231
2167
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2232
2168
  deferred1_0 = r0;
@@ -2234,21 +2170,19 @@ export function scifiPanelDV5(width, height) {
2234
2170
  return getStringFromWasm0(r0, r1);
2235
2171
  } finally {
2236
2172
  wasm.__wbindgen_add_to_stack_pointer(16);
2237
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2173
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2238
2174
  }
2239
2175
  }
2240
2176
 
2241
2177
  /**
2242
- * @param {number} width
2243
- * @param {number} height
2244
2178
  * @returns {string}
2245
2179
  */
2246
- export function scifiPanelDV6(width, height) {
2180
+ export function svgSpinPointC() {
2247
2181
  let deferred1_0;
2248
2182
  let deferred1_1;
2249
2183
  try {
2250
2184
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2251
- wasm.scifiPanelDV6(retptr, width, height);
2185
+ wasm.svgSpinPointC(retptr);
2252
2186
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2253
2187
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2254
2188
  deferred1_0 = r0;
@@ -2256,21 +2190,19 @@ export function scifiPanelDV6(width, height) {
2256
2190
  return getStringFromWasm0(r0, r1);
2257
2191
  } finally {
2258
2192
  wasm.__wbindgen_add_to_stack_pointer(16);
2259
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2193
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2260
2194
  }
2261
2195
  }
2262
2196
 
2263
2197
  /**
2264
- * @param {number} width
2265
- * @param {number} height
2266
2198
  * @returns {string}
2267
2199
  */
2268
- export function scifiPanelDV7(width, height) {
2200
+ export function svgSpinPulseDotA() {
2269
2201
  let deferred1_0;
2270
2202
  let deferred1_1;
2271
2203
  try {
2272
2204
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2273
- wasm.scifiPanelDV7(retptr, width, height);
2205
+ wasm.svgSpinPulseDotA(retptr);
2274
2206
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2275
2207
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2276
2208
  deferred1_0 = r0;
@@ -2278,21 +2210,19 @@ export function scifiPanelDV7(width, height) {
2278
2210
  return getStringFromWasm0(r0, r1);
2279
2211
  } finally {
2280
2212
  wasm.__wbindgen_add_to_stack_pointer(16);
2281
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2213
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2282
2214
  }
2283
2215
  }
2284
2216
 
2285
2217
  /**
2286
- * @param {number} width
2287
- * @param {number} height
2288
2218
  * @returns {string}
2289
2219
  */
2290
- export function scifiPanelDV8(width, height) {
2220
+ export function svgSpinPulseDotB() {
2291
2221
  let deferred1_0;
2292
2222
  let deferred1_1;
2293
2223
  try {
2294
2224
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2295
- wasm.scifiPanelDV8(retptr, width, height);
2225
+ wasm.svgSpinPulseDotB(retptr);
2296
2226
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2297
2227
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2298
2228
  deferred1_0 = r0;
@@ -2300,21 +2230,19 @@ export function scifiPanelDV8(width, height) {
2300
2230
  return getStringFromWasm0(r0, r1);
2301
2231
  } finally {
2302
2232
  wasm.__wbindgen_add_to_stack_pointer(16);
2303
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2233
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2304
2234
  }
2305
2235
  }
2306
2236
 
2307
2237
  /**
2308
- * @param {number} width
2309
- * @param {number} height
2310
2238
  * @returns {string}
2311
2239
  */
2312
- export function scifiPanelDV9(width, height) {
2240
+ export function svgSpinPulseDotC() {
2313
2241
  let deferred1_0;
2314
2242
  let deferred1_1;
2315
2243
  try {
2316
2244
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2317
- wasm.scifiPanelDV9(retptr, width, height);
2245
+ wasm.svgSpinPulseDotC(retptr);
2318
2246
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2319
2247
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2320
2248
  deferred1_0 = r0;
@@ -2322,21 +2250,19 @@ export function scifiPanelDV9(width, height) {
2322
2250
  return getStringFromWasm0(r0, r1);
2323
2251
  } finally {
2324
2252
  wasm.__wbindgen_add_to_stack_pointer(16);
2325
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2253
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2326
2254
  }
2327
2255
  }
2328
2256
 
2329
2257
  /**
2330
- * @param {number} length
2331
- * @param {boolean} has_digits
2332
2258
  * @returns {string}
2333
2259
  */
2334
- export function rdmStr(length, has_digits) {
2260
+ export function svgSpinPulseRingA() {
2335
2261
  let deferred1_0;
2336
2262
  let deferred1_1;
2337
2263
  try {
2338
2264
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2339
- wasm.rdmStr(retptr, length, has_digits);
2265
+ wasm.svgSpinPulseRingA(retptr);
2340
2266
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2341
2267
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2342
2268
  deferred1_0 = r0;
@@ -2344,94 +2270,79 @@ export function rdmStr(length, has_digits) {
2344
2270
  return getStringFromWasm0(r0, r1);
2345
2271
  } finally {
2346
2272
  wasm.__wbindgen_add_to_stack_pointer(16);
2347
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2273
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2348
2274
  }
2349
2275
  }
2350
2276
 
2351
2277
  /**
2352
- * @param {string} input
2353
2278
  * @returns {string}
2354
2279
  */
2355
- export function md5Enc(input) {
2356
- let deferred2_0;
2357
- let deferred2_1;
2280
+ export function svgSpinPulseRingB() {
2281
+ let deferred1_0;
2282
+ let deferred1_1;
2358
2283
  try {
2359
2284
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2360
- const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2361
- const len0 = WASM_VECTOR_LEN;
2362
- wasm.md5Enc(retptr, ptr0, len0);
2285
+ wasm.svgSpinPulseRingB(retptr);
2363
2286
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2364
2287
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2365
- deferred2_0 = r0;
2366
- deferred2_1 = r1;
2288
+ deferred1_0 = r0;
2289
+ deferred1_1 = r1;
2367
2290
  return getStringFromWasm0(r0, r1);
2368
2291
  } finally {
2369
2292
  wasm.__wbindgen_add_to_stack_pointer(16);
2370
- wasm.__wbindgen_export_4(deferred2_0, deferred2_1, 1);
2293
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2371
2294
  }
2372
2295
  }
2373
2296
 
2374
2297
  /**
2375
- * @param {string} plaintext
2376
- * @param {string} key_type
2377
2298
  * @returns {string}
2378
2299
  */
2379
- export function openEnc(plaintext, key_type) {
2380
- let deferred3_0;
2381
- let deferred3_1;
2300
+ export function svgSpinPulseRingC() {
2301
+ let deferred1_0;
2302
+ let deferred1_1;
2382
2303
  try {
2383
2304
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2384
- const ptr0 = passStringToWasm0(plaintext, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2385
- const len0 = WASM_VECTOR_LEN;
2386
- const ptr1 = passStringToWasm0(key_type, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2387
- const len1 = WASM_VECTOR_LEN;
2388
- wasm.openEnc(retptr, ptr0, len0, ptr1, len1);
2305
+ wasm.svgSpinPulseRingC(retptr);
2389
2306
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2390
2307
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2391
- deferred3_0 = r0;
2392
- deferred3_1 = r1;
2308
+ deferred1_0 = r0;
2309
+ deferred1_1 = r1;
2393
2310
  return getStringFromWasm0(r0, r1);
2394
2311
  } finally {
2395
2312
  wasm.__wbindgen_add_to_stack_pointer(16);
2396
- wasm.__wbindgen_export_4(deferred3_0, deferred3_1, 1);
2313
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2397
2314
  }
2398
2315
  }
2399
2316
 
2400
2317
  /**
2401
- * @param {string} ciphertext
2402
- * @param {string} key_type
2403
2318
  * @returns {string}
2404
2319
  */
2405
- export function openDec(ciphertext, key_type) {
2406
- let deferred3_0;
2407
- let deferred3_1;
2320
+ export function svgSpinRingA() {
2321
+ let deferred1_0;
2322
+ let deferred1_1;
2408
2323
  try {
2409
2324
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2410
- const ptr0 = passStringToWasm0(ciphertext, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2411
- const len0 = WASM_VECTOR_LEN;
2412
- const ptr1 = passStringToWasm0(key_type, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2413
- const len1 = WASM_VECTOR_LEN;
2414
- wasm.openDec(retptr, ptr0, len0, ptr1, len1);
2325
+ wasm.svgSpinRingA(retptr);
2415
2326
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2416
2327
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2417
- deferred3_0 = r0;
2418
- deferred3_1 = r1;
2328
+ deferred1_0 = r0;
2329
+ deferred1_1 = r1;
2419
2330
  return getStringFromWasm0(r0, r1);
2420
2331
  } finally {
2421
2332
  wasm.__wbindgen_add_to_stack_pointer(16);
2422
- wasm.__wbindgen_export_4(deferred3_0, deferred3_1, 1);
2333
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2423
2334
  }
2424
2335
  }
2425
2336
 
2426
2337
  /**
2427
2338
  * @returns {string}
2428
2339
  */
2429
- export function getEnv() {
2340
+ export function svgSpinRingB() {
2430
2341
  let deferred1_0;
2431
2342
  let deferred1_1;
2432
2343
  try {
2433
2344
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2434
- wasm.getEnv(retptr);
2345
+ wasm.svgSpinRingB(retptr);
2435
2346
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2436
2347
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2437
2348
  deferred1_0 = r0;
@@ -2439,19 +2350,19 @@ export function getEnv() {
2439
2350
  return getStringFromWasm0(r0, r1);
2440
2351
  } finally {
2441
2352
  wasm.__wbindgen_add_to_stack_pointer(16);
2442
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2353
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2443
2354
  }
2444
2355
  }
2445
2356
 
2446
2357
  /**
2447
2358
  * @returns {string}
2448
2359
  */
2449
- export function getVer() {
2360
+ export function svgSpinRingC() {
2450
2361
  let deferred1_0;
2451
2362
  let deferred1_1;
2452
2363
  try {
2453
2364
  const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2454
- wasm.getVer(retptr);
2365
+ wasm.svgSpinRingC(retptr);
2455
2366
  var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2456
2367
  var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2457
2368
  deferred1_0 = r0;
@@ -2459,146 +2370,718 @@ export function getVer() {
2459
2370
  return getStringFromWasm0(r0, r1);
2460
2371
  } finally {
2461
2372
  wasm.__wbindgen_add_to_stack_pointer(16);
2462
- wasm.__wbindgen_export_4(deferred1_0, deferred1_1, 1);
2373
+ wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
2463
2374
  }
2464
2375
  }
2465
2376
 
2466
- let stack_pointer = 128;
2377
+ /**
2378
+ * @param {number} coeff_ori
2379
+ * @param {number} shadow_coeff_ori
2380
+ * @param {number} dw
2381
+ * @returns {any}
2382
+ */
2383
+ export function t3dCoeffCalc(coeff_ori, shadow_coeff_ori, dw) {
2384
+ const ret = wasm.t3dCoeffCalc(coeff_ori, shadow_coeff_ori, dw);
2385
+ return takeObject(ret);
2386
+ }
2387
+
2388
+ /**
2389
+ * @param {object} event
2390
+ * @param {number} fix_alpha
2391
+ * @param {boolean} ues_alpha
2392
+ * @returns {object}
2393
+ */
2394
+ export function t3dUpdateOrient(event, fix_alpha, ues_alpha) {
2395
+ const ret = wasm.t3dUpdateOrient(addHeapObject(event), fix_alpha, ues_alpha);
2396
+ return takeObject(ret);
2397
+ }
2398
+
2399
+ /**
2400
+ * @param {string} mode
2401
+ * @param {number} coeff
2402
+ * @param {MouseEvent} e
2403
+ * @param {DOMRect} el
2404
+ * @param {number} dh
2405
+ * @param {number} dw
2406
+ * @returns {any}
2407
+ */
2408
+ export function t3dUpdateRotate(mode, coeff, e, el, dh, dw) {
2409
+ const ptr0 = passStringToWasm0(mode, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2410
+ const len0 = WASM_VECTOR_LEN;
2411
+ const ret = wasm.t3dUpdateRotate(ptr0, len0, coeff, addHeapObject(e), addHeapObject(el), dh, dw);
2412
+ return takeObject(ret);
2413
+ }
2414
+
2415
+ /**
2416
+ * @param {string | null} [li_str]
2417
+ * @param {string | null} [sub_str]
2418
+ * @param {string | null} [core_init_str]
2419
+ * @param {string | null} [keychain]
2420
+ */
2421
+ export function techuiCoreInit(li_str, sub_str, core_init_str, keychain) {
2422
+ var ptr0 = isLikeNone(li_str) ? 0 : passStringToWasm0(li_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2423
+ var len0 = WASM_VECTOR_LEN;
2424
+ var ptr1 = isLikeNone(sub_str) ? 0 : passStringToWasm0(sub_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2425
+ var len1 = WASM_VECTOR_LEN;
2426
+ var ptr2 = isLikeNone(core_init_str) ? 0 : passStringToWasm0(core_init_str, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2427
+ var len2 = WASM_VECTOR_LEN;
2428
+ var ptr3 = isLikeNone(keychain) ? 0 : passStringToWasm0(keychain, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2429
+ var len3 = WASM_VECTOR_LEN;
2430
+ wasm.techuiCoreInit(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
2431
+ }
2432
+
2433
+ function __wbg_get_imports() {
2434
+ const import0 = {
2435
+ __proto__: null,
2436
+ __wbg_Error_4577686b3a6d9b3a: function(arg0, arg1) {
2437
+ const ret = Error(getStringFromWasm0(arg0, arg1));
2438
+ return addHeapObject(ret);
2439
+ },
2440
+ __wbg___wbindgen_boolean_get_18c4ed9422296fff: function(arg0) {
2441
+ const v = getObject(arg0);
2442
+ const ret = typeof(v) === 'boolean' ? v : undefined;
2443
+ return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
2444
+ },
2445
+ __wbg___wbindgen_debug_string_ddde1867f49c2442: function(arg0, arg1) {
2446
+ const ret = debugString(getObject(arg1));
2447
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2448
+ const len1 = WASM_VECTOR_LEN;
2449
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2450
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2451
+ },
2452
+ __wbg___wbindgen_in_1064a108f4d18b9e: function(arg0, arg1) {
2453
+ const ret = getObject(arg0) in getObject(arg1);
2454
+ return ret;
2455
+ },
2456
+ __wbg___wbindgen_is_function_d633e708baf0d146: function(arg0) {
2457
+ const ret = typeof(getObject(arg0)) === 'function';
2458
+ return ret;
2459
+ },
2460
+ __wbg___wbindgen_is_object_4b3de556756ee8a8: function(arg0) {
2461
+ const val = getObject(arg0);
2462
+ const ret = typeof(val) === 'object' && val !== null;
2463
+ return ret;
2464
+ },
2465
+ __wbg___wbindgen_is_string_7debe47dc1e045c2: function(arg0) {
2466
+ const ret = typeof(getObject(arg0)) === 'string';
2467
+ return ret;
2468
+ },
2469
+ __wbg___wbindgen_is_undefined_c18285b9fc34cb7d: function(arg0) {
2470
+ const ret = getObject(arg0) === undefined;
2471
+ return ret;
2472
+ },
2473
+ __wbg___wbindgen_jsval_loose_eq_1562ceb9af84e990: function(arg0, arg1) {
2474
+ const ret = getObject(arg0) == getObject(arg1);
2475
+ return ret;
2476
+ },
2477
+ __wbg___wbindgen_number_get_5854912275df1894: function(arg0, arg1) {
2478
+ const obj = getObject(arg1);
2479
+ const ret = typeof(obj) === 'number' ? obj : undefined;
2480
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
2481
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
2482
+ },
2483
+ __wbg___wbindgen_string_get_3e5751597f39a112: function(arg0, arg1) {
2484
+ const obj = getObject(arg1);
2485
+ const ret = typeof(obj) === 'string' ? obj : undefined;
2486
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2487
+ var len1 = WASM_VECTOR_LEN;
2488
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2489
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2490
+ },
2491
+ __wbg___wbindgen_throw_39bc967c0e5a9b58: function(arg0, arg1) {
2492
+ throw new Error(getStringFromWasm0(arg0, arg1));
2493
+ },
2494
+ __wbg__wbg_cb_unref_b6d832240a919168: function(arg0) {
2495
+ getObject(arg0)._wbg_cb_unref();
2496
+ },
2497
+ __wbg_add_db0285f1ee36c7f1: function() { return handleError(function (arg0, arg1, arg2) {
2498
+ getObject(arg0).add(getStringFromWasm0(arg1, arg2));
2499
+ }, arguments); },
2500
+ __wbg_appendChild_f8784f6270d097cd: function() { return handleError(function (arg0, arg1) {
2501
+ const ret = getObject(arg0).appendChild(getObject(arg1));
2502
+ return addHeapObject(ret);
2503
+ }, arguments); },
2504
+ __wbg_call_08ad0d89caa7cb79: function() { return handleError(function (arg0, arg1, arg2) {
2505
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
2506
+ return addHeapObject(ret);
2507
+ }, arguments); },
2508
+ __wbg_call_73af281463ec8b58: function() { return handleError(function (arg0, arg1) {
2509
+ const ret = getObject(arg0).call(getObject(arg1));
2510
+ return addHeapObject(ret);
2511
+ }, arguments); },
2512
+ __wbg_classList_4d6a49c15855e3ea: function(arg0) {
2513
+ const ret = getObject(arg0).classList;
2514
+ return addHeapObject(ret);
2515
+ },
2516
+ __wbg_clearTimeout_113b1cde814ec762: function(arg0) {
2517
+ const ret = clearTimeout(takeObject(arg0));
2518
+ return addHeapObject(ret);
2519
+ },
2520
+ __wbg_clientX_810042c308568d39: function(arg0) {
2521
+ const ret = getObject(arg0).clientX;
2522
+ return ret;
2523
+ },
2524
+ __wbg_clientY_ddce2da9c948105f: function(arg0) {
2525
+ const ret = getObject(arg0).clientY;
2526
+ return ret;
2527
+ },
2528
+ __wbg_createElement_c28be812ac2ffe84: function() { return handleError(function (arg0, arg1, arg2) {
2529
+ const ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
2530
+ return addHeapObject(ret);
2531
+ }, arguments); },
2532
+ __wbg_crypto_b9be447aa422134f: function(arg0) {
2533
+ const ret = getObject(arg0).crypto;
2534
+ return addHeapObject(ret);
2535
+ },
2536
+ __wbg_documentElement_e8e4604dd3a54de3: function(arg0) {
2537
+ const ret = getObject(arg0).documentElement;
2538
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2539
+ },
2540
+ __wbg_document_0b7613236d782ccc: function(arg0) {
2541
+ const ret = getObject(arg0).document;
2542
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2543
+ },
2544
+ __wbg_entries_28d32ba4cd93f5fc: function(arg0) {
2545
+ const ret = Object.entries(getObject(arg0));
2546
+ return addHeapObject(ret);
2547
+ },
2548
+ __wbg_firstChild_fc120ce22d67bd0b: function(arg0) {
2549
+ const ret = getObject(arg0).firstChild;
2550
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2551
+ },
2552
+ __wbg_from_d7e888a2e9063b32: function(arg0) {
2553
+ const ret = Array.from(getObject(arg0));
2554
+ return addHeapObject(ret);
2555
+ },
2556
+ __wbg_getItem_d794ea14168dbca6: function() { return handleError(function (arg0, arg1, arg2, arg3) {
2557
+ const ret = getObject(arg1).getItem(getStringFromWasm0(arg2, arg3));
2558
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2559
+ var len1 = WASM_VECTOR_LEN;
2560
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2561
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2562
+ }, arguments); },
2563
+ __wbg_getOwnPropertyDescriptor_2aaf28dc5e8dee0f: function() { return handleError(function (arg0, arg1) {
2564
+ const ret = Reflect.getOwnPropertyDescriptor(getObject(arg0), getObject(arg1));
2565
+ return addHeapObject(ret);
2566
+ }, arguments); },
2567
+ __wbg_getRandomValues_57f4e4df7a423812: function() { return handleError(function (arg0, arg1) {
2568
+ getObject(arg0).getRandomValues(getObject(arg1));
2569
+ }, arguments); },
2570
+ __wbg_getTime_9429d05129287418: function(arg0) {
2571
+ const ret = getObject(arg0).getTime();
2572
+ return ret;
2573
+ },
2574
+ __wbg_getTimezoneOffset_eeb05f23347950d1: function(arg0) {
2575
+ const ret = getObject(arg0).getTimezoneOffset();
2576
+ return ret;
2577
+ },
2578
+ __wbg_get_18349afdb36339a9: function() { return handleError(function (arg0, arg1) {
2579
+ const ret = Reflect.get(getObject(arg0), getObject(arg1));
2580
+ return addHeapObject(ret);
2581
+ }, arguments); },
2582
+ __wbg_get_f09c3a16f8848381: function(arg0, arg1) {
2583
+ const ret = getObject(arg0)[arg1 >>> 0];
2584
+ return addHeapObject(ret);
2585
+ },
2586
+ __wbg_get_with_ref_key_6412cf3094599694: function(arg0, arg1) {
2587
+ const ret = getObject(arg0)[getObject(arg1)];
2588
+ return addHeapObject(ret);
2589
+ },
2590
+ __wbg_height_60b6be274c385565: function(arg0) {
2591
+ const ret = getObject(arg0).height;
2592
+ return ret;
2593
+ },
2594
+ __wbg_hostname_5f0dc31def0fb6fc: function() { return handleError(function (arg0, arg1) {
2595
+ const ret = getObject(arg1).hostname;
2596
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2597
+ const len1 = WASM_VECTOR_LEN;
2598
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2599
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2600
+ }, arguments); },
2601
+ __wbg_innerHTML_d92f0646cba8f0fd: function(arg0, arg1) {
2602
+ const ret = getObject(arg1).innerHTML;
2603
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2604
+ const len1 = WASM_VECTOR_LEN;
2605
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2606
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2607
+ },
2608
+ __wbg_insertBefore_8a8f9c2f8b2135a2: function() { return handleError(function (arg0, arg1, arg2) {
2609
+ const ret = getObject(arg0).insertBefore(getObject(arg1), getObject(arg2));
2610
+ return addHeapObject(ret);
2611
+ }, arguments); },
2612
+ __wbg_instanceof_ArrayBuffer_15859862b80b732d: function(arg0) {
2613
+ let result;
2614
+ try {
2615
+ result = getObject(arg0) instanceof ArrayBuffer;
2616
+ } catch (_) {
2617
+ result = false;
2618
+ }
2619
+ const ret = result;
2620
+ return ret;
2621
+ },
2622
+ __wbg_instanceof_Uint8Array_2240b7046ac16f05: function(arg0) {
2623
+ let result;
2624
+ try {
2625
+ result = getObject(arg0) instanceof Uint8Array;
2626
+ } catch (_) {
2627
+ result = false;
2628
+ }
2629
+ const ret = result;
2630
+ return ret;
2631
+ },
2632
+ __wbg_instanceof_Window_4aba49e4d1a12365: function(arg0) {
2633
+ let result;
2634
+ try {
2635
+ result = getObject(arg0) instanceof Window;
2636
+ } catch (_) {
2637
+ result = false;
2638
+ }
2639
+ const ret = result;
2640
+ return ret;
2641
+ },
2642
+ __wbg_left_271b4450c739c266: function(arg0) {
2643
+ const ret = getObject(arg0).left;
2644
+ return ret;
2645
+ },
2646
+ __wbg_length_5855c1f289dfffc1: function(arg0) {
2647
+ const ret = getObject(arg0).length;
2648
+ return ret;
2649
+ },
2650
+ __wbg_length_a31e05262e09b7f8: function(arg0) {
2651
+ const ret = getObject(arg0).length;
2652
+ return ret;
2653
+ },
2654
+ __wbg_location_e18b1d47af5ae20f: function(arg0) {
2655
+ const ret = getObject(arg0).location;
2656
+ return addHeapObject(ret);
2657
+ },
2658
+ __wbg_msCrypto_99c672bc62a82892: function(arg0) {
2659
+ const ret = getObject(arg0).msCrypto;
2660
+ return addHeapObject(ret);
2661
+ },
2662
+ __wbg_new_09959f7b4c92c246: function(arg0) {
2663
+ const ret = new Uint8Array(getObject(arg0));
2664
+ return addHeapObject(ret);
2665
+ },
2666
+ __wbg_new_0_a719938e6f92ddf4: function() {
2667
+ const ret = new Date();
2668
+ return addHeapObject(ret);
2669
+ },
2670
+ __wbg_new_223944ca37c18764: function(arg0) {
2671
+ const ret = new Date(getObject(arg0));
2672
+ return addHeapObject(ret);
2673
+ },
2674
+ __wbg_new_cbee8c0d5c479eac: function() {
2675
+ const ret = new Array();
2676
+ return addHeapObject(ret);
2677
+ },
2678
+ __wbg_new_ed69e637b553a997: function() {
2679
+ const ret = new Object();
2680
+ return addHeapObject(ret);
2681
+ },
2682
+ __wbg_new_no_args_c2e69c5334809a64: function(arg0, arg1) {
2683
+ const ret = new Function(getStringFromWasm0(arg0, arg1));
2684
+ return addHeapObject(ret);
2685
+ },
2686
+ __wbg_new_with_data_9db2920ae61354e8: function() { return handleError(function (arg0, arg1) {
2687
+ const ret = new Comment(getStringFromWasm0(arg0, arg1));
2688
+ return addHeapObject(ret);
2689
+ }, arguments); },
2690
+ __wbg_new_with_length_c8449d782396d344: function(arg0) {
2691
+ const ret = new Uint8Array(arg0 >>> 0);
2692
+ return addHeapObject(ret);
2693
+ },
2694
+ __wbg_node_ac5a354e22181b95: function(arg0) {
2695
+ const ret = getObject(arg0).node;
2696
+ return addHeapObject(ret);
2697
+ },
2698
+ __wbg_ownerDocument_56cb65d61a07472b: function(arg0) {
2699
+ const ret = getObject(arg0).ownerDocument;
2700
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2701
+ },
2702
+ __wbg_process_99502ff594d66db2: function(arg0) {
2703
+ const ret = getObject(arg0).process;
2704
+ return addHeapObject(ret);
2705
+ },
2706
+ __wbg_prototypesetcall_f034d444741426c3: function(arg0, arg1, arg2) {
2707
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
2708
+ },
2709
+ __wbg_querySelector_5a9cd5c59506cf7a: function() { return handleError(function (arg0, arg1, arg2) {
2710
+ const ret = getObject(arg0).querySelector(getStringFromWasm0(arg1, arg2));
2711
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2712
+ }, arguments); },
2713
+ __wbg_randomFillSync_c30a6c2d3e809182: function() { return handleError(function (arg0, arg1) {
2714
+ getObject(arg0).randomFillSync(takeObject(arg1));
2715
+ }, arguments); },
2716
+ __wbg_remove_575c01e4788cfef7: function(arg0) {
2717
+ getObject(arg0).remove();
2718
+ },
2719
+ __wbg_remove_82deb5c82cdf36fd: function() { return handleError(function (arg0, arg1, arg2) {
2720
+ getObject(arg0).remove(getStringFromWasm0(arg1, arg2));
2721
+ }, arguments); },
2722
+ __wbg_require_ceb6837efca524c5: function() { return handleError(function () {
2723
+ const ret = module.require;
2724
+ return addHeapObject(ret);
2725
+ }, arguments); },
2726
+ __wbg_sessionStorage_f7a8465998a76d75: function() { return handleError(function (arg0) {
2727
+ const ret = getObject(arg0).sessionStorage;
2728
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2729
+ }, arguments); },
2730
+ __wbg_setItem_0c9c2d583a540407: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
2731
+ getObject(arg0).setItem(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
2732
+ }, arguments); },
2733
+ __wbg_setTimeout_ef24d2fc3ad97385: function() { return handleError(function (arg0, arg1) {
2734
+ const ret = setTimeout(getObject(arg0), arg1);
2735
+ return addHeapObject(ret);
2736
+ }, arguments); },
2737
+ __wbg_set_4c81cfb5dc3a333c: function(arg0, arg1, arg2) {
2738
+ getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
2739
+ },
2740
+ __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
2741
+ getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
2742
+ },
2743
+ __wbg_set_bad5c505cc70b5f8: function() { return handleError(function (arg0, arg1, arg2) {
2744
+ const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
2745
+ return ret;
2746
+ }, arguments); },
2747
+ __wbg_set_id_f8c968f125e444d9: function(arg0, arg1, arg2) {
2748
+ getObject(arg0).id = getStringFromWasm0(arg1, arg2);
2749
+ },
2750
+ __wbg_set_innerHTML_a0467b14e22a2cb9: function(arg0, arg1, arg2) {
2751
+ getObject(arg0).innerHTML = getStringFromWasm0(arg1, arg2);
2752
+ },
2753
+ __wbg_set_title_c1a249003c79f71c: function(arg0, arg1, arg2) {
2754
+ getObject(arg0).title = getStringFromWasm0(arg1, arg2);
2755
+ },
2756
+ __wbg_static_accessor_GLOBAL_THIS_14325d8cca34bb77: function() {
2757
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
2758
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2759
+ },
2760
+ __wbg_static_accessor_GLOBAL_f3a1e69f9c5a7e8e: function() {
2761
+ const ret = typeof global === 'undefined' ? null : global;
2762
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2763
+ },
2764
+ __wbg_static_accessor_SELF_50cdb5b517789aca: function() {
2765
+ const ret = typeof self === 'undefined' ? null : self;
2766
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2767
+ },
2768
+ __wbg_static_accessor_WINDOW_d6c4126e4c244380: function() {
2769
+ const ret = typeof window === 'undefined' ? null : window;
2770
+ return isLikeNone(ret) ? 0 : addHeapObject(ret);
2771
+ },
2772
+ __wbg_subarray_7ad5f01d4a9c1c4d: function(arg0, arg1, arg2) {
2773
+ const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
2774
+ return addHeapObject(ret);
2775
+ },
2776
+ __wbg_title_83f93bf5440f43ea: function(arg0, arg1) {
2777
+ const ret = getObject(arg1).title;
2778
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
2779
+ const len1 = WASM_VECTOR_LEN;
2780
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2781
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2782
+ },
2783
+ __wbg_toString_3efd854029ba20fb: function(arg0) {
2784
+ const ret = getObject(arg0).toString();
2785
+ return addHeapObject(ret);
2786
+ },
2787
+ __wbg_toggle_08994f58f03b6d85: function() { return handleError(function (arg0, arg1, arg2) {
2788
+ const ret = getObject(arg0).toggle(getStringFromWasm0(arg1, arg2));
2789
+ return ret;
2790
+ }, arguments); },
2791
+ __wbg_top_8b55ad858d42fd2e: function(arg0) {
2792
+ const ret = getObject(arg0).top;
2793
+ return ret;
2794
+ },
2795
+ __wbg_versions_4f6b17dcf04db054: function(arg0) {
2796
+ const ret = getObject(arg0).versions;
2797
+ return addHeapObject(ret);
2798
+ },
2799
+ __wbg_width_e2e02ec713b253dc: function(arg0) {
2800
+ const ret = getObject(arg0).width;
2801
+ return ret;
2802
+ },
2803
+ __wbindgen_cast_0000000000000001: function(arg0, arg1) {
2804
+ // Cast intrinsic for `Closure(Closure { dtor_idx: 1, function: Function { arguments: [], shim_idx: 2, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
2805
+ const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_92, __wasm_bindgen_func_elem_335);
2806
+ return addHeapObject(ret);
2807
+ },
2808
+ __wbindgen_cast_0000000000000002: function(arg0) {
2809
+ // Cast intrinsic for `F64 -> Externref`.
2810
+ const ret = arg0;
2811
+ return addHeapObject(ret);
2812
+ },
2813
+ __wbindgen_cast_0000000000000003: function(arg0, arg1) {
2814
+ // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
2815
+ const ret = getArrayU8FromWasm0(arg0, arg1);
2816
+ return addHeapObject(ret);
2817
+ },
2818
+ __wbindgen_cast_0000000000000004: function(arg0, arg1) {
2819
+ // Cast intrinsic for `Ref(String) -> Externref`.
2820
+ const ret = getStringFromWasm0(arg0, arg1);
2821
+ return addHeapObject(ret);
2822
+ },
2823
+ __wbindgen_object_clone_ref: function(arg0) {
2824
+ const ret = getObject(arg0);
2825
+ return addHeapObject(ret);
2826
+ },
2827
+ __wbindgen_object_drop_ref: function(arg0) {
2828
+ takeObject(arg0);
2829
+ },
2830
+ };
2831
+ return {
2832
+ __proto__: null,
2833
+ "./core_bg.js": import0,
2834
+ };
2835
+ }
2836
+
2837
+ function __wasm_bindgen_func_elem_335(arg0, arg1) {
2838
+ wasm.__wasm_bindgen_func_elem_335(arg0, arg1);
2839
+ }
2840
+
2841
+ function addHeapObject(obj) {
2842
+ if (heap_next === heap.length) heap.push(heap.length + 1);
2843
+ const idx = heap_next;
2844
+ heap_next = heap[idx];
2845
+
2846
+ heap[idx] = obj;
2847
+ return idx;
2848
+ }
2467
2849
 
2468
2850
  function addBorrowedObject(obj) {
2469
2851
  if (stack_pointer == 1) throw new Error('out of js stack');
2470
2852
  heap[--stack_pointer] = obj;
2471
2853
  return stack_pointer;
2472
2854
  }
2473
- /**
2474
- * @param {string} prefix
2475
- * @param {object} style_obj
2476
- * @returns {string}
2477
- */
2478
- export function cssVarGen(prefix, style_obj) {
2479
- let deferred2_0;
2480
- let deferred2_1;
2481
- try {
2482
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2483
- const ptr0 = passStringToWasm0(prefix, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2484
- const len0 = WASM_VECTOR_LEN;
2485
- wasm.cssVarGen(retptr, ptr0, len0, addBorrowedObject(style_obj));
2486
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2487
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2488
- deferred2_0 = r0;
2489
- deferred2_1 = r1;
2490
- return getStringFromWasm0(r0, r1);
2491
- } finally {
2492
- wasm.__wbindgen_add_to_stack_pointer(16);
2493
- heap[stack_pointer++] = undefined;
2494
- wasm.__wbindgen_export_4(deferred2_0, deferred2_1, 1);
2855
+
2856
+ const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
2857
+ ? { register: () => {}, unregister: () => {} }
2858
+ : new FinalizationRegistry(state => state.dtor(state.a, state.b));
2859
+
2860
+ function debugString(val) {
2861
+ // primitive types
2862
+ const type = typeof val;
2863
+ if (type == 'number' || type == 'boolean' || val == null) {
2864
+ return `${val}`;
2865
+ }
2866
+ if (type == 'string') {
2867
+ return `"${val}"`;
2868
+ }
2869
+ if (type == 'symbol') {
2870
+ const description = val.description;
2871
+ if (description == null) {
2872
+ return 'Symbol';
2873
+ } else {
2874
+ return `Symbol(${description})`;
2875
+ }
2876
+ }
2877
+ if (type == 'function') {
2878
+ const name = val.name;
2879
+ if (typeof name == 'string' && name.length > 0) {
2880
+ return `Function(${name})`;
2881
+ } else {
2882
+ return 'Function';
2883
+ }
2884
+ }
2885
+ // objects
2886
+ if (Array.isArray(val)) {
2887
+ const length = val.length;
2888
+ let debug = '[';
2889
+ if (length > 0) {
2890
+ debug += debugString(val[0]);
2891
+ }
2892
+ for(let i = 1; i < length; i++) {
2893
+ debug += ', ' + debugString(val[i]);
2894
+ }
2895
+ debug += ']';
2896
+ return debug;
2897
+ }
2898
+ // Test for built-in
2899
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
2900
+ let className;
2901
+ if (builtInMatches && builtInMatches.length > 1) {
2902
+ className = builtInMatches[1];
2903
+ } else {
2904
+ // Failed to match the standard '[object ClassName]'
2905
+ return toString.call(val);
2906
+ }
2907
+ if (className == 'Object') {
2908
+ // we're a user defined class or Object
2909
+ // JSON.stringify avoids problems with cycles, and is generally much
2910
+ // easier than looping through ownProperties of `val`.
2911
+ try {
2912
+ return 'Object(' + JSON.stringify(val) + ')';
2913
+ } catch (_) {
2914
+ return 'Object';
2915
+ }
2916
+ }
2917
+ // errors
2918
+ if (val instanceof Error) {
2919
+ return `${val.name}: ${val.message}\n${val.stack}`;
2920
+ }
2921
+ // TODO we could test for more things here, like `Set`s and `Map`s.
2922
+ return className;
2923
+ }
2924
+
2925
+ function dropObject(idx) {
2926
+ if (idx < 1028) return;
2927
+ heap[idx] = heap_next;
2928
+ heap_next = idx;
2929
+ }
2930
+
2931
+ function getArrayU8FromWasm0(ptr, len) {
2932
+ ptr = ptr >>> 0;
2933
+ return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
2934
+ }
2935
+
2936
+ let cachedDataViewMemory0 = null;
2937
+ function getDataViewMemory0() {
2938
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
2939
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
2940
+ }
2941
+ return cachedDataViewMemory0;
2942
+ }
2943
+
2944
+ function getStringFromWasm0(ptr, len) {
2945
+ ptr = ptr >>> 0;
2946
+ return decodeText(ptr, len);
2947
+ }
2948
+
2949
+ let cachedUint8ArrayMemory0 = null;
2950
+ function getUint8ArrayMemory0() {
2951
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
2952
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
2953
+ }
2954
+ return cachedUint8ArrayMemory0;
2955
+ }
2956
+
2957
+ function getObject(idx) { return heap[idx]; }
2958
+
2959
+ function handleError(f, args) {
2960
+ try {
2961
+ return f.apply(this, args);
2962
+ } catch (e) {
2963
+ wasm.__wbindgen_export3(addHeapObject(e));
2495
2964
  }
2496
2965
  }
2497
2966
 
2498
- /**
2499
- * @param {string} errstr
2500
- * @param {string} msg
2501
- */
2502
- export function coreConsoleError(errstr, msg) {
2503
- const ptr0 = passStringToWasm0(errstr, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2504
- const len0 = WASM_VECTOR_LEN;
2505
- const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2506
- const len1 = WASM_VECTOR_LEN;
2507
- wasm.coreConsoleError(ptr0, len0, ptr1, len1);
2508
- }
2967
+ let heap = new Array(1024).fill(undefined);
2968
+ heap.push(undefined, null, true, false);
2509
2969
 
2510
- /**
2511
- * @param {string} warnstr
2512
- * @param {string} msg
2513
- */
2514
- export function coreConsoleWarn(warnstr, msg) {
2515
- const ptr0 = passStringToWasm0(warnstr, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2516
- const len0 = WASM_VECTOR_LEN;
2517
- const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2518
- const len1 = WASM_VECTOR_LEN;
2519
- wasm.coreConsoleWarn(ptr0, len0, ptr1, len1);
2520
- }
2970
+ let heap_next = heap.length;
2521
2971
 
2522
- /**
2523
- * @param {string} infostr
2524
- * @param {string} msg
2525
- */
2526
- export function coreConsoleInfo(infostr, msg) {
2527
- const ptr0 = passStringToWasm0(infostr, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2528
- const len0 = WASM_VECTOR_LEN;
2529
- const ptr1 = passStringToWasm0(msg, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2530
- const len1 = WASM_VECTOR_LEN;
2531
- wasm.coreConsoleInfo(ptr0, len0, ptr1, len1);
2972
+ function isLikeNone(x) {
2973
+ return x === undefined || x === null;
2532
2974
  }
2533
2975
 
2534
- /**
2535
- * @param {any} input
2536
- * @returns {any}
2537
- */
2538
- export function coreInfo(input) {
2539
- const ret = wasm.coreInfo(addHeapObject(input));
2540
- return takeObject(ret);
2976
+ function makeMutClosure(arg0, arg1, dtor, f) {
2977
+ const state = { a: arg0, b: arg1, cnt: 1, dtor };
2978
+ const real = (...args) => {
2979
+
2980
+ // First up with a closure we increment the internal reference
2981
+ // count. This ensures that the Rust closure environment won't
2982
+ // be deallocated while we're invoking it.
2983
+ state.cnt++;
2984
+ const a = state.a;
2985
+ state.a = 0;
2986
+ try {
2987
+ return f(a, state.b, ...args);
2988
+ } finally {
2989
+ state.a = a;
2990
+ real._wbg_cb_unref();
2991
+ }
2992
+ };
2993
+ real._wbg_cb_unref = () => {
2994
+ if (--state.cnt === 0) {
2995
+ state.dtor(state.a, state.b);
2996
+ state.a = 0;
2997
+ CLOSURE_DTORS.unregister(state);
2998
+ }
2999
+ };
3000
+ CLOSURE_DTORS.register(real, state, state);
3001
+ return real;
2541
3002
  }
2542
3003
 
2543
- /**
2544
- * @param {string} input
2545
- * @returns {string}
2546
- */
2547
- export function cidGen(input) {
2548
- let deferred2_0;
2549
- let deferred2_1;
2550
- try {
2551
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
2552
- const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2553
- const len0 = WASM_VECTOR_LEN;
2554
- wasm.cidGen(retptr, ptr0, len0);
2555
- var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
2556
- var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
2557
- deferred2_0 = r0;
2558
- deferred2_1 = r1;
2559
- return getStringFromWasm0(r0, r1);
2560
- } finally {
2561
- wasm.__wbindgen_add_to_stack_pointer(16);
2562
- wasm.__wbindgen_export_4(deferred2_0, deferred2_1, 1);
3004
+ function passStringToWasm0(arg, malloc, realloc) {
3005
+ if (realloc === undefined) {
3006
+ const buf = cachedTextEncoder.encode(arg);
3007
+ const ptr = malloc(buf.length, 1) >>> 0;
3008
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
3009
+ WASM_VECTOR_LEN = buf.length;
3010
+ return ptr;
3011
+ }
3012
+
3013
+ let len = arg.length;
3014
+ let ptr = malloc(len, 1) >>> 0;
3015
+
3016
+ const mem = getUint8ArrayMemory0();
3017
+
3018
+ let offset = 0;
3019
+
3020
+ for (; offset < len; offset++) {
3021
+ const code = arg.charCodeAt(offset);
3022
+ if (code > 0x7F) break;
3023
+ mem[ptr + offset] = code;
3024
+ }
3025
+ if (offset !== len) {
3026
+ if (offset !== 0) {
3027
+ arg = arg.slice(offset);
3028
+ }
3029
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
3030
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
3031
+ const ret = cachedTextEncoder.encodeInto(arg, view);
3032
+
3033
+ offset += ret.written;
3034
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
2563
3035
  }
3036
+
3037
+ WASM_VECTOR_LEN = offset;
3038
+ return ptr;
2564
3039
  }
2565
3040
 
2566
- /**
2567
- * @param {string} uid
2568
- * @param {string} classname
2569
- * @returns {boolean}
2570
- */
2571
- export function cidVaild(uid, classname) {
2572
- const ptr0 = passStringToWasm0(uid, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2573
- const len0 = WASM_VECTOR_LEN;
2574
- const ptr1 = passStringToWasm0(classname, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2575
- const len1 = WASM_VECTOR_LEN;
2576
- const ret = wasm.cidVaild(ptr0, len0, ptr1, len1);
2577
- return ret !== 0;
3041
+ let stack_pointer = 1024;
3042
+
3043
+ function takeObject(idx) {
3044
+ const ret = getObject(idx);
3045
+ dropObject(idx);
3046
+ return ret;
2578
3047
  }
2579
3048
 
2580
- export function floatInfo() {
2581
- wasm.floatInfo();
3049
+ let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
3050
+ cachedTextDecoder.decode();
3051
+ const MAX_SAFARI_DECODE_BYTES = 2146435072;
3052
+ let numBytesDecoded = 0;
3053
+ function decodeText(ptr, len) {
3054
+ numBytesDecoded += len;
3055
+ if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
3056
+ cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
3057
+ cachedTextDecoder.decode();
3058
+ numBytesDecoded = len;
3059
+ }
3060
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
2582
3061
  }
2583
3062
 
2584
- /**
2585
- * @param {string | null | undefined} li_str
2586
- * @param {string | null | undefined} sub_str
2587
- * @param {string | null | undefined} core_init_str
2588
- * @param {any} npmkeys
2589
- */
2590
- export function techuiCoreInit(li_str, sub_str, core_init_str, npmkeys) {
2591
- var ptr0 = isLikeNone(li_str) ? 0 : passStringToWasm0(li_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2592
- var len0 = WASM_VECTOR_LEN;
2593
- var ptr1 = isLikeNone(sub_str) ? 0 : passStringToWasm0(sub_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2594
- var len1 = WASM_VECTOR_LEN;
2595
- var ptr2 = isLikeNone(core_init_str) ? 0 : passStringToWasm0(core_init_str, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2596
- var len2 = WASM_VECTOR_LEN;
2597
- wasm.techuiCoreInit(ptr0, len0, ptr1, len1, ptr2, len2, addHeapObject(npmkeys));
3063
+ const cachedTextEncoder = new TextEncoder();
3064
+
3065
+ if (!('encodeInto' in cachedTextEncoder)) {
3066
+ cachedTextEncoder.encodeInto = function (arg, view) {
3067
+ const buf = cachedTextEncoder.encode(arg);
3068
+ view.set(buf);
3069
+ return {
3070
+ read: arg.length,
3071
+ written: buf.length
3072
+ };
3073
+ };
2598
3074
  }
2599
3075
 
2600
- function __wbg_adapter_38(arg0, arg1) {
2601
- wasm.__wbindgen_export_5(arg0, arg1);
3076
+ let WASM_VECTOR_LEN = 0;
3077
+
3078
+ let wasmModule, wasm;
3079
+ function __wbg_finalize_init(instance, module) {
3080
+ wasm = instance.exports;
3081
+ wasmModule = module;
3082
+ cachedDataViewMemory0 = null;
3083
+ cachedUint8ArrayMemory0 = null;
3084
+ return wasm;
2602
3085
  }
2603
3086
 
2604
3087
  async function __wbg_load(module, imports) {
@@ -2606,459 +3089,41 @@ async function __wbg_load(module, imports) {
2606
3089
  if (typeof WebAssembly.instantiateStreaming === 'function') {
2607
3090
  try {
2608
3091
  return await WebAssembly.instantiateStreaming(module, imports);
2609
-
2610
3092
  } catch (e) {
2611
- if (module.headers.get('Content-Type') != 'application/wasm') {
3093
+ const validResponse = module.ok && expectedResponseType(module.type);
3094
+
3095
+ if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
2612
3096
  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);
2613
3097
 
2614
- } else {
2615
- throw e;
2616
- }
3098
+ } else { throw e; }
2617
3099
  }
2618
3100
  }
2619
3101
 
2620
3102
  const bytes = await module.arrayBuffer();
2621
3103
  return await WebAssembly.instantiate(bytes, imports);
2622
-
2623
3104
  } else {
2624
3105
  const instance = await WebAssembly.instantiate(module, imports);
2625
3106
 
2626
3107
  if (instance instanceof WebAssembly.Instance) {
2627
3108
  return { instance, module };
2628
-
2629
3109
  } else {
2630
3110
  return instance;
2631
3111
  }
2632
3112
  }
2633
- }
2634
3113
 
2635
- function __wbg_get_imports() {
2636
- const imports = {};
2637
- imports.wbg = {};
2638
- imports.wbg.__wbg_add_9b5191a4a4f767dc = function() { return handleError(function (arg0, arg1, arg2) {
2639
- getObject(arg0).add(getStringFromWasm0(arg1, arg2));
2640
- }, arguments) };
2641
- imports.wbg.__wbg_appendChild_8204974b7328bf98 = function() { return handleError(function (arg0, arg1) {
2642
- const ret = getObject(arg0).appendChild(getObject(arg1));
2643
- return addHeapObject(ret);
2644
- }, arguments) };
2645
- imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
2646
- const ret = getObject(arg0).buffer;
2647
- return addHeapObject(ret);
2648
- };
2649
- imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
2650
- const ret = getObject(arg0).call(getObject(arg1));
2651
- return addHeapObject(ret);
2652
- }, arguments) };
2653
- imports.wbg.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
2654
- const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
2655
- return addHeapObject(ret);
2656
- }, arguments) };
2657
- imports.wbg.__wbg_classList_3fa995ef71da9e8e = function(arg0) {
2658
- const ret = getObject(arg0).classList;
2659
- return addHeapObject(ret);
2660
- };
2661
- imports.wbg.__wbg_clearTimeout_5a54f8841c30079a = function(arg0) {
2662
- const ret = clearTimeout(takeObject(arg0));
2663
- return addHeapObject(ret);
2664
- };
2665
- imports.wbg.__wbg_clientX_5eb380a5f1fec6fd = function(arg0) {
2666
- const ret = getObject(arg0).clientX;
2667
- return ret;
2668
- };
2669
- imports.wbg.__wbg_clientY_d8b9c7f0c4e2e677 = function(arg0) {
2670
- const ret = getObject(arg0).clientY;
2671
- return ret;
2672
- };
2673
- imports.wbg.__wbg_createElement_8c9931a732ee2fea = function() { return handleError(function (arg0, arg1, arg2) {
2674
- const ret = getObject(arg0).createElement(getStringFromWasm0(arg1, arg2));
2675
- return addHeapObject(ret);
2676
- }, arguments) };
2677
- imports.wbg.__wbg_crypto_ab727e271e83bfb9 = function(arg0) {
2678
- const ret = getObject(arg0).crypto;
2679
- return addHeapObject(ret);
2680
- };
2681
- imports.wbg.__wbg_documentElement_197a88c262a0aa27 = function(arg0) {
2682
- const ret = getObject(arg0).documentElement;
2683
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2684
- };
2685
- imports.wbg.__wbg_document_d249400bd7bd996d = function(arg0) {
2686
- const ret = getObject(arg0).document;
2687
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2688
- };
2689
- imports.wbg.__wbg_entries_3265d4158b33e5dc = function(arg0) {
2690
- const ret = Object.entries(getObject(arg0));
2691
- return addHeapObject(ret);
2692
- };
2693
- imports.wbg.__wbg_eval_e10dc02e9547f640 = function() { return handleError(function (arg0, arg1) {
2694
- const ret = eval(getStringFromWasm0(arg0, arg1));
2695
- return addHeapObject(ret);
2696
- }, arguments) };
2697
- imports.wbg.__wbg_firstChild_b0603462b5172539 = function(arg0) {
2698
- const ret = getObject(arg0).firstChild;
2699
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2700
- };
2701
- imports.wbg.__wbg_from_2a5d3e218e67aa85 = function(arg0) {
2702
- const ret = Array.from(getObject(arg0));
2703
- return addHeapObject(ret);
2704
- };
2705
- imports.wbg.__wbg_getItem_17f98dee3b43fa7e = function() { return handleError(function (arg0, arg1, arg2, arg3) {
2706
- const ret = getObject(arg1).getItem(getStringFromWasm0(arg2, arg3));
2707
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2708
- var len1 = WASM_VECTOR_LEN;
2709
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2710
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2711
- }, arguments) };
2712
- imports.wbg.__wbg_getRandomValues_e2aed5b1dc8645ee = function() { return handleError(function (arg0, arg1) {
2713
- getObject(arg0).getRandomValues(getObject(arg1));
2714
- }, arguments) };
2715
- imports.wbg.__wbg_getTime_46267b1c24877e30 = function(arg0) {
2716
- const ret = getObject(arg0).getTime();
2717
- return ret;
2718
- };
2719
- imports.wbg.__wbg_getTimezoneOffset_6b5752021c499c47 = function(arg0) {
2720
- const ret = getObject(arg0).getTimezoneOffset();
2721
- return ret;
2722
- };
2723
- imports.wbg.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
2724
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
2725
- return addHeapObject(ret);
2726
- }, arguments) };
2727
- imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
2728
- const ret = getObject(arg0)[arg1 >>> 0];
2729
- return addHeapObject(ret);
2730
- };
2731
- imports.wbg.__wbg_getwithrefkey_1dc361bd10053bfe = function(arg0, arg1) {
2732
- const ret = getObject(arg0)[getObject(arg1)];
2733
- return addHeapObject(ret);
2734
- };
2735
- imports.wbg.__wbg_height_592a89ec0fb63726 = function(arg0) {
2736
- const ret = getObject(arg0).height;
2737
- return ret;
2738
- };
2739
- imports.wbg.__wbg_hostname_8d7204884eb7378b = function() { return handleError(function (arg0, arg1) {
2740
- const ret = getObject(arg1).hostname;
2741
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2742
- const len1 = WASM_VECTOR_LEN;
2743
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2744
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2745
- }, arguments) };
2746
- imports.wbg.__wbg_innerHTML_e1553352fe93921a = function(arg0, arg1) {
2747
- const ret = getObject(arg1).innerHTML;
2748
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2749
- const len1 = WASM_VECTOR_LEN;
2750
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2751
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2752
- };
2753
- imports.wbg.__wbg_insertBefore_c181fb91844cd959 = function() { return handleError(function (arg0, arg1, arg2) {
2754
- const ret = getObject(arg0).insertBefore(getObject(arg1), getObject(arg2));
2755
- return addHeapObject(ret);
2756
- }, arguments) };
2757
- imports.wbg.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
2758
- let result;
2759
- try {
2760
- result = getObject(arg0) instanceof ArrayBuffer;
2761
- } catch (_) {
2762
- result = false;
2763
- }
2764
- const ret = result;
2765
- return ret;
2766
- };
2767
- imports.wbg.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) {
2768
- let result;
2769
- try {
2770
- result = getObject(arg0) instanceof Uint8Array;
2771
- } catch (_) {
2772
- result = false;
2773
- }
2774
- const ret = result;
2775
- return ret;
2776
- };
2777
- imports.wbg.__wbg_instanceof_Window_def73ea0955fc569 = function(arg0) {
2778
- let result;
2779
- try {
2780
- result = getObject(arg0) instanceof Window;
2781
- } catch (_) {
2782
- result = false;
2783
- }
2784
- const ret = result;
2785
- return ret;
2786
- };
2787
- imports.wbg.__wbg_left_e46801720267b66d = function(arg0) {
2788
- const ret = getObject(arg0).left;
2789
- return ret;
2790
- };
2791
- imports.wbg.__wbg_length_a446193dc22c12f8 = function(arg0) {
2792
- const ret = getObject(arg0).length;
2793
- return ret;
2794
- };
2795
- imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
2796
- const ret = getObject(arg0).length;
2797
- return ret;
2798
- };
2799
- imports.wbg.__wbg_location_350d99456c2f3693 = function(arg0) {
2800
- const ret = getObject(arg0).location;
2801
- return addHeapObject(ret);
2802
- };
2803
- imports.wbg.__wbg_msCrypto_858989c3e8f87e60 = function(arg0) {
2804
- const ret = getObject(arg0).msCrypto;
2805
- return addHeapObject(ret);
2806
- };
2807
- imports.wbg.__wbg_new0_f788a2397c7ca929 = function() {
2808
- const ret = new Date();
2809
- return addHeapObject(ret);
2810
- };
2811
- imports.wbg.__wbg_new_405e22f390576ce2 = function() {
2812
- const ret = new Object();
2813
- return addHeapObject(ret);
2814
- };
2815
- imports.wbg.__wbg_new_78feb108b6472713 = function() {
2816
- const ret = new Array();
2817
- return addHeapObject(ret);
2818
- };
2819
- imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
2820
- const ret = new Uint8Array(getObject(arg0));
2821
- return addHeapObject(ret);
2822
- };
2823
- imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
2824
- const ret = new Function(getStringFromWasm0(arg0, arg1));
2825
- return addHeapObject(ret);
2826
- };
2827
- imports.wbg.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
2828
- const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
2829
- return addHeapObject(ret);
2830
- };
2831
- imports.wbg.__wbg_newwithdata_6412cd8a3af8f1ef = function() { return handleError(function (arg0, arg1) {
2832
- const ret = new Comment(getStringFromWasm0(arg0, arg1));
2833
- return addHeapObject(ret);
2834
- }, arguments) };
2835
- imports.wbg.__wbg_newwithlength_a381634e90c276d4 = function(arg0) {
2836
- const ret = new Uint8Array(arg0 >>> 0);
2837
- return addHeapObject(ret);
2838
- };
2839
- imports.wbg.__wbg_node_a1a2feca7a914889 = function(arg0) {
2840
- const ret = getObject(arg0).node;
2841
- return addHeapObject(ret);
2842
- };
2843
- imports.wbg.__wbg_ownerDocument_243e06ce3350b842 = function(arg0) {
2844
- const ret = getObject(arg0).ownerDocument;
2845
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2846
- };
2847
- imports.wbg.__wbg_process_ad7fb702cc30e9d3 = function(arg0) {
2848
- const ret = getObject(arg0).process;
2849
- return addHeapObject(ret);
2850
- };
2851
- imports.wbg.__wbg_querySelector_c69f8b573958906b = function() { return handleError(function (arg0, arg1, arg2) {
2852
- const ret = getObject(arg0).querySelector(getStringFromWasm0(arg1, arg2));
2853
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2854
- }, arguments) };
2855
- imports.wbg.__wbg_randomFillSync_e9c0014ab6e905fd = function() { return handleError(function (arg0, arg1) {
2856
- getObject(arg0).randomFillSync(takeObject(arg1));
2857
- }, arguments) };
2858
- imports.wbg.__wbg_remove_282d941ca37d0c63 = function() { return handleError(function (arg0, arg1, arg2) {
2859
- getObject(arg0).remove(getStringFromWasm0(arg1, arg2));
2860
- }, arguments) };
2861
- imports.wbg.__wbg_remove_e2d2659f3128c045 = function(arg0) {
2862
- getObject(arg0).remove();
2863
- };
2864
- imports.wbg.__wbg_require_be7c9aaf6587f97e = function() { return handleError(function () {
2865
- const ret = module.require;
2866
- return addHeapObject(ret);
2867
- }, arguments) };
2868
- imports.wbg.__wbg_sessionStorage_06138fc301bf45ca = function() { return handleError(function (arg0) {
2869
- const ret = getObject(arg0).sessionStorage;
2870
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2871
- }, arguments) };
2872
- imports.wbg.__wbg_setItem_212ecc915942ab0a = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
2873
- getObject(arg0).setItem(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
2874
- }, arguments) };
2875
- imports.wbg.__wbg_setTimeout_db2dbaeefb6f39c7 = function() { return handleError(function (arg0, arg1) {
2876
- const ret = setTimeout(getObject(arg0), arg1);
2877
- return addHeapObject(ret);
2878
- }, arguments) };
2879
- imports.wbg.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
2880
- getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
2881
- };
2882
- imports.wbg.__wbg_set_3f1d0b984ed272ed = function(arg0, arg1, arg2) {
2883
- getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
2884
- };
2885
- imports.wbg.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
2886
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
2887
- };
2888
- imports.wbg.__wbg_set_bb8cecf6a62b9f46 = function() { return handleError(function (arg0, arg1, arg2) {
2889
- const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
2890
- return ret;
2891
- }, arguments) };
2892
- imports.wbg.__wbg_setid_d1300d55a412791b = function(arg0, arg1, arg2) {
2893
- getObject(arg0).id = getStringFromWasm0(arg1, arg2);
2894
- };
2895
- imports.wbg.__wbg_setinnerHTML_31bde41f835786f7 = function(arg0, arg1, arg2) {
2896
- getObject(arg0).innerHTML = getStringFromWasm0(arg1, arg2);
2897
- };
2898
- imports.wbg.__wbg_settitle_f779989743070c28 = function(arg0, arg1, arg2) {
2899
- getObject(arg0).title = getStringFromWasm0(arg1, arg2);
2900
- };
2901
- imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
2902
- const ret = typeof global === 'undefined' ? null : global;
2903
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2904
- };
2905
- imports.wbg.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
2906
- const ret = typeof globalThis === 'undefined' ? null : globalThis;
2907
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2908
- };
2909
- imports.wbg.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
2910
- const ret = typeof self === 'undefined' ? null : self;
2911
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2912
- };
2913
- imports.wbg.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
2914
- const ret = typeof window === 'undefined' ? null : window;
2915
- return isLikeNone(ret) ? 0 : addHeapObject(ret);
2916
- };
2917
- imports.wbg.__wbg_subarray_aa9065fa9dc5df96 = function(arg0, arg1, arg2) {
2918
- const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
2919
- return addHeapObject(ret);
2920
- };
2921
- imports.wbg.__wbg_title_09f6e06f98d0b686 = function(arg0, arg1) {
2922
- const ret = getObject(arg1).title;
2923
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2924
- const len1 = WASM_VECTOR_LEN;
2925
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2926
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2927
- };
2928
- imports.wbg.__wbg_toString_085f123fb88c76f1 = function(arg0) {
2929
- const ret = getObject(arg0).toString();
2930
- return addHeapObject(ret);
2931
- };
2932
- imports.wbg.__wbg_toggle_eb55caf936454eda = function() { return handleError(function (arg0, arg1, arg2) {
2933
- const ret = getObject(arg0).toggle(getStringFromWasm0(arg1, arg2));
2934
- return ret;
2935
- }, arguments) };
2936
- imports.wbg.__wbg_top_ec9fceb1f030f2ea = function(arg0) {
2937
- const ret = getObject(arg0).top;
2938
- return ret;
2939
- };
2940
- imports.wbg.__wbg_versions_32faad06f7206ef9 = function(arg0) {
2941
- const ret = getObject(arg0).versions;
2942
- return addHeapObject(ret);
2943
- };
2944
- imports.wbg.__wbg_width_f0759bd8bad335bd = function(arg0) {
2945
- const ret = getObject(arg0).width;
2946
- return ret;
2947
- };
2948
- imports.wbg.__wbindgen_boolean_get = function(arg0) {
2949
- const v = getObject(arg0);
2950
- const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
2951
- return ret;
2952
- };
2953
- imports.wbg.__wbindgen_cb_drop = function(arg0) {
2954
- const obj = takeObject(arg0).original;
2955
- if (obj.cnt-- == 1) {
2956
- obj.a = 0;
2957
- return true;
3114
+ function expectedResponseType(type) {
3115
+ switch (type) {
3116
+ case 'basic': case 'cors': case 'default': return true;
2958
3117
  }
2959
- const ret = false;
2960
- return ret;
2961
- };
2962
- imports.wbg.__wbindgen_closure_wrapper150 = function(arg0, arg1, arg2) {
2963
- const ret = makeMutClosure(arg0, arg1, 5, __wbg_adapter_38);
2964
- return addHeapObject(ret);
2965
- };
2966
- imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
2967
- const ret = debugString(getObject(arg1));
2968
- const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
2969
- const len1 = WASM_VECTOR_LEN;
2970
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
2971
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
2972
- };
2973
- imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
2974
- const ret = new Error(getStringFromWasm0(arg0, arg1));
2975
- return addHeapObject(ret);
2976
- };
2977
- imports.wbg.__wbindgen_in = function(arg0, arg1) {
2978
- const ret = getObject(arg0) in getObject(arg1);
2979
- return ret;
2980
- };
2981
- imports.wbg.__wbindgen_is_function = function(arg0) {
2982
- const ret = typeof(getObject(arg0)) === 'function';
2983
- return ret;
2984
- };
2985
- imports.wbg.__wbindgen_is_object = function(arg0) {
2986
- const val = getObject(arg0);
2987
- const ret = typeof(val) === 'object' && val !== null;
2988
- return ret;
2989
- };
2990
- imports.wbg.__wbindgen_is_string = function(arg0) {
2991
- const ret = typeof(getObject(arg0)) === 'string';
2992
- return ret;
2993
- };
2994
- imports.wbg.__wbindgen_is_undefined = function(arg0) {
2995
- const ret = getObject(arg0) === undefined;
2996
- return ret;
2997
- };
2998
- imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
2999
- const ret = getObject(arg0) == getObject(arg1);
3000
- return ret;
3001
- };
3002
- imports.wbg.__wbindgen_memory = function() {
3003
- const ret = wasm.memory;
3004
- return addHeapObject(ret);
3005
- };
3006
- imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
3007
- const obj = getObject(arg1);
3008
- const ret = typeof(obj) === 'number' ? obj : undefined;
3009
- getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
3010
- getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
3011
- };
3012
- imports.wbg.__wbindgen_number_new = function(arg0) {
3013
- const ret = arg0;
3014
- return addHeapObject(ret);
3015
- };
3016
- imports.wbg.__wbindgen_object_clone_ref = function(arg0) {
3017
- const ret = getObject(arg0);
3018
- return addHeapObject(ret);
3019
- };
3020
- imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
3021
- takeObject(arg0);
3022
- };
3023
- imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
3024
- const obj = getObject(arg1);
3025
- const ret = typeof(obj) === 'string' ? obj : undefined;
3026
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_export_1, wasm.__wbindgen_export_2);
3027
- var len1 = WASM_VECTOR_LEN;
3028
- getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3029
- getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3030
- };
3031
- imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
3032
- const ret = getStringFromWasm0(arg0, arg1);
3033
- return addHeapObject(ret);
3034
- };
3035
- imports.wbg.__wbindgen_throw = function(arg0, arg1) {
3036
- throw new Error(getStringFromWasm0(arg0, arg1));
3037
- };
3038
-
3039
- return imports;
3040
- }
3041
-
3042
- function __wbg_init_memory(imports, memory) {
3043
-
3044
- }
3045
-
3046
- function __wbg_finalize_init(instance, module) {
3047
- wasm = instance.exports;
3048
- __wbg_init.__wbindgen_wasm_module = module;
3049
- cachedDataViewMemory0 = null;
3050
- cachedUint8ArrayMemory0 = null;
3051
-
3052
-
3053
-
3054
- return wasm;
3118
+ return false;
3119
+ }
3055
3120
  }
3056
3121
 
3057
3122
  function initSync(module) {
3058
3123
  if (wasm !== undefined) return wasm;
3059
3124
 
3060
3125
 
3061
- if (typeof module !== 'undefined') {
3126
+ if (module !== undefined) {
3062
3127
  if (Object.getPrototypeOf(module) === Object.prototype) {
3063
3128
  ({module} = module)
3064
3129
  } else {
@@ -3067,15 +3132,10 @@ function initSync(module) {
3067
3132
  }
3068
3133
 
3069
3134
  const imports = __wbg_get_imports();
3070
-
3071
- __wbg_init_memory(imports);
3072
-
3073
3135
  if (!(module instanceof WebAssembly.Module)) {
3074
3136
  module = new WebAssembly.Module(module);
3075
3137
  }
3076
-
3077
3138
  const instance = new WebAssembly.Instance(module, imports);
3078
-
3079
3139
  return __wbg_finalize_init(instance, module);
3080
3140
  }
3081
3141
 
@@ -3083,7 +3143,7 @@ async function __wbg_init(module_or_path) {
3083
3143
  if (wasm !== undefined) return wasm;
3084
3144
 
3085
3145
 
3086
- if (typeof module_or_path !== 'undefined') {
3146
+ if (module_or_path !== undefined) {
3087
3147
  if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
3088
3148
  ({module_or_path} = module_or_path)
3089
3149
  } else {
@@ -3091,7 +3151,7 @@ async function __wbg_init(module_or_path) {
3091
3151
  }
3092
3152
  }
3093
3153
 
3094
- if (typeof module_or_path === 'undefined') {
3154
+ if (module_or_path === undefined) {
3095
3155
  module_or_path = new URL('core_bg.wasm', import.meta.url);
3096
3156
  }
3097
3157
  const imports = __wbg_get_imports();
@@ -3100,12 +3160,9 @@ async function __wbg_init(module_or_path) {
3100
3160
  module_or_path = fetch(module_or_path);
3101
3161
  }
3102
3162
 
3103
- __wbg_init_memory(imports);
3104
-
3105
3163
  const { instance, module } = await __wbg_load(await module_or_path, imports);
3106
3164
 
3107
3165
  return __wbg_finalize_init(instance, module);
3108
3166
  }
3109
3167
 
3110
- export { initSync };
3111
- export default __wbg_init;
3168
+ export { initSync, __wbg_init as default };