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