@scalable-vector-audio/sva-wasm 0.9.5 → 0.9.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +1 -1
- package/sva_wasm.d.ts +173 -1
- package/sva_wasm.js +70 -44
- package/sva_wasm_bg.wasm +0 -0
package/package.json
CHANGED
package/sva_wasm.d.ts
CHANGED
|
@@ -1,6 +1,164 @@
|
|
|
1
1
|
/* tslint:disable */
|
|
2
2
|
/* eslint-disable */
|
|
3
3
|
|
|
4
|
+
/** What one call did so far, or every call of one composition since its subscriber took it. */
|
|
5
|
+
export interface EngineWork {
|
|
6
|
+
/** Samples of the target delivered. */
|
|
7
|
+
samples: number;
|
|
8
|
+
/**
|
|
9
|
+
* The work scale, in samples of values: `cached_samples + computed_samples` is the work
|
|
10
|
+
* done, and `cached_samples / (cached_samples + computed_samples)` the share of it that was
|
|
11
|
+
* cached. A value is the target or anything it reads; a sample of one counts once per call.
|
|
12
|
+
*
|
|
13
|
+
* `cached_samples`: samples answered by what memory or the store held before the call
|
|
14
|
+
* began, counted as the call reads them. Nothing the call itself computed counts, however
|
|
15
|
+
* often it reads it back. A cached value counts its own samples only: the work that once
|
|
16
|
+
* computed it and everything beneath it is not known, so a target read back whole counts
|
|
17
|
+
* the target's samples and nothing else. They are counted only while a subscriber
|
|
18
|
+
* listens: a call under way when its subscriber arrives counts them from then on.
|
|
19
|
+
*/
|
|
20
|
+
cached_samples: number;
|
|
21
|
+
/** The part of `cached_samples` whose value the store answered for this call. */
|
|
22
|
+
cached_from_store_samples: number;
|
|
23
|
+
/** Samples computed, summed over every value: 0 when all was read back. */
|
|
24
|
+
computed_samples: number;
|
|
25
|
+
/**
|
|
26
|
+
* Lookups by what each came to, the counts `Rendering.stats()` ends at: unweighted, and
|
|
27
|
+
* `reused` counts a call's reads of what it computed itself, so no share of work is read
|
|
28
|
+
* off them. Cached: `hit` (`from_memory` + `from_store`). Uncached: `miss`, and `prefix`
|
|
29
|
+
* (found only in part). `new`: misses kept for the next call. A count may fall as a lookup
|
|
30
|
+
* settles.
|
|
31
|
+
*/
|
|
32
|
+
lookups: {
|
|
33
|
+
hit: number; from_memory: number; from_store: number;
|
|
34
|
+
prefix: number; miss: number; new: number; reused: number;
|
|
35
|
+
};
|
|
36
|
+
/** Memory's disk traffic meanwhile, whichever call asked: `Rendering.stats().tier`. */
|
|
37
|
+
tier: {
|
|
38
|
+
disk_lookups: number; disk_reads: number; disk_read_bytes: number; promotions: number;
|
|
39
|
+
writebacks: number; hits: number; evictions: number;
|
|
40
|
+
probation_evictions: number; protected_evictions: number;
|
|
41
|
+
};
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
/** One call: a render, a stream from its open on, one stream edit, or a persist. */
|
|
45
|
+
export interface EngineCall extends EngineWork {
|
|
46
|
+
/** Counted from 1 over the composition, never given twice. */
|
|
47
|
+
id: number;
|
|
48
|
+
kind: "render" | "stream" | "edit" | "persist";
|
|
49
|
+
/** As the page wrote it; a persist's is empty. */
|
|
50
|
+
target: string;
|
|
51
|
+
/**
|
|
52
|
+
* Samples are delivered in `delivering` alone. `done`, `failed` and `abandoned` end the call:
|
|
53
|
+
* its last report.
|
|
54
|
+
*/
|
|
55
|
+
phase: "parsing" | "typing" | "looking_up" | "planning" | "fetching" | "delivering"
|
|
56
|
+
| "finishing" | "storing" | "done" | "failed" | "abandoned";
|
|
57
|
+
/**
|
|
58
|
+
* What `samples` counts up to. null until the range is decided (before `delivering`), and
|
|
59
|
+
* for a stream whose end is open.
|
|
60
|
+
*/
|
|
61
|
+
total_samples: number | null;
|
|
62
|
+
/**
|
|
63
|
+
* What `cached_samples + computed_samples` counts up to: the call's whole work, so
|
|
64
|
+
* `(cached_samples + computed_samples) / planned_samples` is its progress, moving while a
|
|
65
|
+
* long pull delivers nothing. It is what the engine now plans, never an estimate: every
|
|
66
|
+
* sample its values still have to read back or compute over the rest of the range. The
|
|
67
|
+
* plan is corrected, by about a hundredth at most where measured, when the first block is
|
|
68
|
+
* pulled: only then is it known which values memory answers on their first read, and what
|
|
69
|
+
* the run-up before the first block left held. It is corrected again where memory lets go
|
|
70
|
+
* of a value meanwhile, and where `until` ends the call early. The work done never falls,
|
|
71
|
+
* and a call that ends `done` ends with the two equal. null until the call's values are built
|
|
72
|
+
* (before `delivering`), for a persist, and for a stream whose end is open: there the
|
|
73
|
+
* engine knows no total, and the counts stand alone.
|
|
74
|
+
*/
|
|
75
|
+
planned_samples: number | null;
|
|
76
|
+
/**
|
|
77
|
+
* A render's typing, `typed` of `nodes`: null for a stream, an edit and a persist, which
|
|
78
|
+
* report the phase alone, and null in a render until the instances the target reaches are
|
|
79
|
+
* scanned: the engine finds them as it scans, so that stretch has no total and reports no
|
|
80
|
+
* count. `instances`: how many it reaches. `nodes`: how many this call types, 0 where the
|
|
81
|
+
* composition's last call typed them all. `typed`: how many are typed so far, ending at
|
|
82
|
+
* `nodes`. What follows in `typing` (naming each node by what it computes, and bounding
|
|
83
|
+
* the target) reports no count either.
|
|
84
|
+
*/
|
|
85
|
+
typing: { instances: number; nodes: number; typed: number } | null;
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
/**
|
|
89
|
+
* The engine starting, heard by the module's `subscribe` alone. `startThreads` reports
|
|
90
|
+
* `starting_threads`, then `threads_started` or `threads_failed`. `Composition.open` reports
|
|
91
|
+
* `opening_store` (waiting for the store's lock), `reading_index`, `index_read`, then
|
|
92
|
+
* `opened`; `store_failed` then `opened` where the store would not open and memory runs
|
|
93
|
+
* alone; `opened` alone where it was handed no directory. `new Composition()` reports none.
|
|
94
|
+
* Fetching and compiling the wasm module happen before any engine code runs: they are the
|
|
95
|
+
* page's to report.
|
|
96
|
+
*/
|
|
97
|
+
export interface EngineBoot {
|
|
98
|
+
phase: "starting_threads" | "threads_started" | "threads_failed"
|
|
99
|
+
| "opening_store" | "reading_index" | "index_read" | "store_failed" | "opened";
|
|
100
|
+
/**
|
|
101
|
+
* The threads asked for in `starting_threads`, else the pool's: null where none started.
|
|
102
|
+
* The pool starts as one step: no count of threads up so far exists.
|
|
103
|
+
*/
|
|
104
|
+
threads: number | null;
|
|
105
|
+
/** null where no store is opened: in `store_failed`, how far its opening got. */
|
|
106
|
+
store: {
|
|
107
|
+
/** The store's budget. */
|
|
108
|
+
max_bytes: number;
|
|
109
|
+
/** The index file's size; null until `index_read`. */
|
|
110
|
+
index_bytes: number | null;
|
|
111
|
+
/** The entries the index names, and their bytes; null until `index_read`. */
|
|
112
|
+
entries: number | null;
|
|
113
|
+
bytes: number | null;
|
|
114
|
+
} | null;
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
/**
|
|
118
|
+
* One report of the module's `subscribe` or of `Composition.subscribe`. A call reports when
|
|
119
|
+
* it begins, at each new phase, while `typing` once a hundredth more of its nodes are typed,
|
|
120
|
+
* per fetch from the store while `fetching`, while `delivering` at block boundaries no more
|
|
121
|
+
* than ten times per second of samples delivered and once a hundredth more of its planned work
|
|
122
|
+
* is done, and when it ends. The callback runs inside the call, on the thread that made it,
|
|
123
|
+
* never on a render thread: a worker forwards each report with `postMessage`. A page on the
|
|
124
|
+
* engine's own thread hears every report as it is made, but paints nothing until the call
|
|
125
|
+
* yields to the event loop, which a render does between blocks only when given a `signal` or
|
|
126
|
+
* reading a store. What the callback throws is logged, and stops nothing. The hook only
|
|
127
|
+
* observes: samples and stored bytes are the same subscribed or not.
|
|
128
|
+
*/
|
|
129
|
+
export interface EngineStats {
|
|
130
|
+
/**
|
|
131
|
+
* "working" while a render, a stream's open, an edit or a persist is in flight. A stream's
|
|
132
|
+
* reads never count: what they report says "idle" unless such a call is in flight beside it.
|
|
133
|
+
* "booting" in a boot report whose step is still under way.
|
|
134
|
+
*/
|
|
135
|
+
state: "working" | "idle" | "booting";
|
|
136
|
+
/** How many such calls are in flight in the composition reporting; 0 in a boot report. */
|
|
137
|
+
working: number;
|
|
138
|
+
/** The boot step this report is about; null in every report of a composition. */
|
|
139
|
+
boot: EngineBoot | null;
|
|
140
|
+
/**
|
|
141
|
+
* The call this report is about; null in a boot report and in the one report a
|
|
142
|
+
* composition answers its new subscriber with.
|
|
143
|
+
*/
|
|
144
|
+
call: EngineCall | null;
|
|
145
|
+
/** Every call's work in the composition reporting since its subscriber took it. */
|
|
146
|
+
totals: EngineWork;
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
/**
|
|
150
|
+
* One subscription for the module: `callback`, in place of the last one, hears the boot
|
|
151
|
+
* (`startThreads`, each `Composition.open`) and every composition, open now or made later,
|
|
152
|
+
* that has no subscriber of its own, each as `Composition.subscribe` reports it. Subscribe
|
|
153
|
+
* before `startThreads` and `open` to hear them. At teardown, `unsubscribe`, or terminate the
|
|
154
|
+
* worker: either leaves nothing behind.
|
|
155
|
+
*/
|
|
156
|
+
export function subscribe(callback: (stats: EngineStats) => void): void;
|
|
157
|
+
/** The module's subscriber hears no more; a composition's own is left as it is. */
|
|
158
|
+
export function unsubscribe(): void;
|
|
159
|
+
|
|
160
|
+
|
|
161
|
+
|
|
4
162
|
export class Composition {
|
|
5
163
|
free(): void;
|
|
6
164
|
[Symbol.dispose](): void;
|
|
@@ -33,6 +191,15 @@ export class Composition {
|
|
|
33
191
|
* `threads` (as `open` takes it).
|
|
34
192
|
*/
|
|
35
193
|
stream(target: string, block: number, options: any): Promise<Stream>;
|
|
194
|
+
/**
|
|
195
|
+
* `callback`, in place of the last one and of the module's, hears an `EngineStats` at
|
|
196
|
+
* once, then from every call of this composition.
|
|
197
|
+
*/
|
|
198
|
+
subscribe(callback: (stats: EngineStats) => void): void;
|
|
199
|
+
/**
|
|
200
|
+
* The module's subscriber, where there is one, hears it from here on.
|
|
201
|
+
*/
|
|
202
|
+
unsubscribe(): void;
|
|
36
203
|
readonly cache_bytes: number;
|
|
37
204
|
readonly cache_entries: number;
|
|
38
205
|
readonly cache_evictions: number;
|
|
@@ -127,7 +294,8 @@ export class Stream {
|
|
|
127
294
|
export function initThreadPool(num_threads: number): Promise<any>;
|
|
128
295
|
|
|
129
296
|
/**
|
|
130
|
-
* Once, from a worker of a cross-origin isolated page.
|
|
297
|
+
* Once, from a worker of a cross-origin isolated page. The module's subscriber hears it start
|
|
298
|
+
* as an `EngineBoot`.
|
|
131
299
|
*/
|
|
132
300
|
export function startThreads(threads: number): Promise<void>;
|
|
133
301
|
|
|
@@ -164,6 +332,8 @@ export interface InitOutput {
|
|
|
164
332
|
readonly composition_store_bytes: (a: number) => [number, number];
|
|
165
333
|
readonly composition_store_max_bytes: (a: number) => [number, number];
|
|
166
334
|
readonly composition_stream: (a: number, b: number, c: number, d: number, e: any) => any;
|
|
335
|
+
readonly composition_subscribe: (a: number, b: any) => void;
|
|
336
|
+
readonly composition_unsubscribe: (a: number) => void;
|
|
167
337
|
readonly initThreadPool: (a: number) => any;
|
|
168
338
|
readonly rendering_channels: (a: number) => number;
|
|
169
339
|
readonly rendering_duration_secs: (a: number) => number;
|
|
@@ -189,6 +359,8 @@ export interface InitOutput {
|
|
|
189
359
|
readonly stream_sample_rate: (a: number) => number;
|
|
190
360
|
readonly stream_stats: (a: number) => [number, number, number];
|
|
191
361
|
readonly stream_work: (a: number) => [number, number, number];
|
|
362
|
+
readonly subscribe: (a: any) => void;
|
|
363
|
+
readonly unsubscribe: () => void;
|
|
192
364
|
readonly wbg_rayon_poolbuilder_build: (a: number) => void;
|
|
193
365
|
readonly wbg_rayon_poolbuilder_mainJS: (a: number) => any;
|
|
194
366
|
readonly wbg_rayon_poolbuilder_numThreads: (a: number) => number;
|
package/sva_wasm.js
CHANGED
|
@@ -157,6 +157,20 @@ export class Composition {
|
|
|
157
157
|
const ret = wasm.composition_stream(this.__wbg_ptr, ptr0, len0, block, options);
|
|
158
158
|
return ret;
|
|
159
159
|
}
|
|
160
|
+
/**
|
|
161
|
+
* `callback`, in place of the last one and of the module's, hears an `EngineStats` at
|
|
162
|
+
* once, then from every call of this composition.
|
|
163
|
+
* @param {(stats: EngineStats) => void} callback
|
|
164
|
+
*/
|
|
165
|
+
subscribe(callback) {
|
|
166
|
+
wasm.composition_subscribe(this.__wbg_ptr, callback);
|
|
167
|
+
}
|
|
168
|
+
/**
|
|
169
|
+
* The module's subscriber, where there is one, hears it from here on.
|
|
170
|
+
*/
|
|
171
|
+
unsubscribe() {
|
|
172
|
+
wasm.composition_unsubscribe(this.__wbg_ptr);
|
|
173
|
+
}
|
|
160
174
|
}
|
|
161
175
|
if (Symbol.dispose) Composition.prototype[Symbol.dispose] = Composition.prototype.free;
|
|
162
176
|
|
|
@@ -439,7 +453,8 @@ export function initThreadPool(num_threads) {
|
|
|
439
453
|
}
|
|
440
454
|
|
|
441
455
|
/**
|
|
442
|
-
* Once, from a worker of a cross-origin isolated page.
|
|
456
|
+
* Once, from a worker of a cross-origin isolated page. The module's subscriber hears it start
|
|
457
|
+
* as an `EngineBoot`.
|
|
443
458
|
* @param {number} threads
|
|
444
459
|
* @returns {Promise<void>}
|
|
445
460
|
*/
|
|
@@ -448,6 +463,17 @@ export function startThreads(threads) {
|
|
|
448
463
|
return ret;
|
|
449
464
|
}
|
|
450
465
|
|
|
466
|
+
/**
|
|
467
|
+
* @param {Function} callback
|
|
468
|
+
*/
|
|
469
|
+
export function subscribe(callback) {
|
|
470
|
+
wasm.subscribe(callback);
|
|
471
|
+
}
|
|
472
|
+
|
|
473
|
+
export function unsubscribe() {
|
|
474
|
+
wasm.unsubscribe();
|
|
475
|
+
}
|
|
476
|
+
|
|
451
477
|
export class wbg_rayon_PoolBuilder {
|
|
452
478
|
static __wrap(ptr) {
|
|
453
479
|
const obj = Object.create(wbg_rayon_PoolBuilder.prototype);
|
|
@@ -560,7 +586,7 @@ function __wbg_get_imports(memory) {
|
|
|
560
586
|
__wbg__wbg_cb_unref_997e73d32238e655: function(arg0) {
|
|
561
587
|
arg0._wbg_cb_unref();
|
|
562
588
|
},
|
|
563
|
-
|
|
589
|
+
__wbg_arrayBuffer_9ad87094932f6cb9: function(arg0) {
|
|
564
590
|
const ret = arg0.arrayBuffer();
|
|
565
591
|
return ret;
|
|
566
592
|
},
|
|
@@ -580,18 +606,18 @@ function __wbg_get_imports(memory) {
|
|
|
580
606
|
const ret = arg0.call(arg1, arg2);
|
|
581
607
|
return ret;
|
|
582
608
|
}, arguments); },
|
|
583
|
-
|
|
609
|
+
__wbg_close_7bc57de15a5a262c: function(arg0) {
|
|
610
|
+
arg0.close();
|
|
611
|
+
},
|
|
612
|
+
__wbg_close_90c4f8b82ef8f25d: function(arg0) {
|
|
584
613
|
const ret = arg0.close();
|
|
585
614
|
return ret;
|
|
586
615
|
},
|
|
587
|
-
__wbg_close_1fc7943048263f1c: function(arg0) {
|
|
588
|
-
arg0.close();
|
|
589
|
-
},
|
|
590
616
|
__wbg_composition_new: function(arg0) {
|
|
591
617
|
const ret = Composition.__wrap(arg0);
|
|
592
618
|
return ret;
|
|
593
619
|
},
|
|
594
|
-
|
|
620
|
+
__wbg_createWritable_592bfb428e0074c4: function(arg0) {
|
|
595
621
|
const ret = arg0.createWritable();
|
|
596
622
|
return ret;
|
|
597
623
|
},
|
|
@@ -607,15 +633,15 @@ function __wbg_get_imports(memory) {
|
|
|
607
633
|
const ret = Array.from(arg0);
|
|
608
634
|
return ret;
|
|
609
635
|
},
|
|
610
|
-
|
|
636
|
+
__wbg_getDirectoryHandle_92ea92a2cf425351: function(arg0, arg1, arg2, arg3) {
|
|
611
637
|
const ret = arg0.getDirectoryHandle(getStringFromWasm0(arg1, arg2), arg3);
|
|
612
638
|
return ret;
|
|
613
639
|
},
|
|
614
|
-
|
|
640
|
+
__wbg_getFileHandle_300e5d6b9533bb83: function(arg0, arg1, arg2, arg3) {
|
|
615
641
|
const ret = arg0.getFileHandle(getStringFromWasm0(arg1, arg2), arg3);
|
|
616
642
|
return ret;
|
|
617
643
|
},
|
|
618
|
-
|
|
644
|
+
__wbg_getFile_2ced7a0f6c787d32: function(arg0) {
|
|
619
645
|
const ret = arg0.getFile();
|
|
620
646
|
return ret;
|
|
621
647
|
},
|
|
@@ -659,7 +685,7 @@ function __wbg_get_imports(memory) {
|
|
|
659
685
|
const ret = Array.isArray(arg0);
|
|
660
686
|
return ret;
|
|
661
687
|
},
|
|
662
|
-
|
|
688
|
+
__wbg_keys_aa4884d7c20a0267: function(arg0) {
|
|
663
689
|
const ret = arg0.keys();
|
|
664
690
|
return ret;
|
|
665
691
|
},
|
|
@@ -675,11 +701,11 @@ function __wbg_get_imports(memory) {
|
|
|
675
701
|
const ret = arg0.length;
|
|
676
702
|
return ret;
|
|
677
703
|
},
|
|
678
|
-
|
|
704
|
+
__wbg_move_e21e6efa3d4a0943: function(arg0, arg1, arg2, arg3) {
|
|
679
705
|
const ret = arg0.move(arg1, getStringFromWasm0(arg2, arg3));
|
|
680
706
|
return ret;
|
|
681
707
|
},
|
|
682
|
-
|
|
708
|
+
__wbg_name_b87f92c7dca3bee8: function(arg0, arg1) {
|
|
683
709
|
const ret = arg1.name;
|
|
684
710
|
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
685
711
|
const len1 = WASM_VECTOR_LEN;
|
|
@@ -690,12 +716,16 @@ function __wbg_get_imports(memory) {
|
|
|
690
716
|
const ret = new Int32Array(arg0);
|
|
691
717
|
return ret;
|
|
692
718
|
},
|
|
719
|
+
__wbg_new_09edd496ab7b3efa: function() {
|
|
720
|
+
const ret = new MessageChannel();
|
|
721
|
+
return ret;
|
|
722
|
+
},
|
|
693
723
|
__wbg_new_1da3429bc3c4541c: function(arg0) {
|
|
694
724
|
const ret = new Uint8Array(arg0);
|
|
695
725
|
return ret;
|
|
696
726
|
},
|
|
697
|
-
|
|
698
|
-
const ret = new
|
|
727
|
+
__wbg_new_2f005795cc40639e: function(arg0, arg1) {
|
|
728
|
+
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
699
729
|
return ret;
|
|
700
730
|
},
|
|
701
731
|
__wbg_new_8f72ed7c652bf5a2: function(arg0, arg1) {
|
|
@@ -720,10 +750,6 @@ function __wbg_get_imports(memory) {
|
|
|
720
750
|
const ret = new Object();
|
|
721
751
|
return ret;
|
|
722
752
|
},
|
|
723
|
-
__wbg_new_c38fc43a35a11a41: function(arg0, arg1) {
|
|
724
|
-
const ret = new Error(getStringFromWasm0(arg0, arg1));
|
|
725
|
-
return ret;
|
|
726
|
-
},
|
|
727
753
|
__wbg_new_from_slice_4ee02165f9de919e: function(arg0, arg1) {
|
|
728
754
|
const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
|
|
729
755
|
return ret;
|
|
@@ -750,7 +776,7 @@ function __wbg_get_imports(memory) {
|
|
|
750
776
|
const ret = new Worker(getStringFromWasm0(arg0, arg1));
|
|
751
777
|
return ret;
|
|
752
778
|
},
|
|
753
|
-
|
|
779
|
+
__wbg_next_550411310a5b8f19: function(arg0) {
|
|
754
780
|
const ret = arg0.next();
|
|
755
781
|
return ret;
|
|
756
782
|
},
|
|
@@ -758,28 +784,28 @@ function __wbg_get_imports(memory) {
|
|
|
758
784
|
const ret = Array.of(arg0, arg1, arg2);
|
|
759
785
|
return ret;
|
|
760
786
|
},
|
|
761
|
-
|
|
787
|
+
__wbg_parse_723a87c4ff290c37: function() { return handleError(function (arg0, arg1) {
|
|
762
788
|
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
|
|
763
789
|
return ret;
|
|
764
790
|
}, arguments); },
|
|
765
|
-
|
|
791
|
+
__wbg_port1_5a15b0e347714dc5: function(arg0) {
|
|
766
792
|
const ret = arg0.port1;
|
|
767
793
|
return ret;
|
|
768
794
|
},
|
|
769
|
-
|
|
795
|
+
__wbg_port2_c30e5d3ba1dce0e2: function(arg0) {
|
|
770
796
|
const ret = arg0.port2;
|
|
771
797
|
return ret;
|
|
772
798
|
},
|
|
799
|
+
__wbg_postMessage_29f2f4e22ce8c237: function(arg0, arg1) {
|
|
800
|
+
arg0.postMessage(arg1);
|
|
801
|
+
},
|
|
773
802
|
__wbg_postMessage_8105a302ed002474: function() { return handleError(function (arg0, arg1) {
|
|
774
803
|
arg0.postMessage(arg1);
|
|
775
804
|
}, arguments); },
|
|
776
|
-
__wbg_postMessage_993ae22fc5c9c66c: function(arg0, arg1) {
|
|
777
|
-
arg0.postMessage(arg1);
|
|
778
|
-
},
|
|
779
805
|
__wbg_prototypesetcall_ae9f5e7459250748: function(arg0, arg1, arg2) {
|
|
780
806
|
Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
|
|
781
807
|
},
|
|
782
|
-
|
|
808
|
+
__wbg_query_d570390809dc58be: function(arg0) {
|
|
783
809
|
const ret = arg0.query();
|
|
784
810
|
return ret;
|
|
785
811
|
},
|
|
@@ -794,19 +820,19 @@ function __wbg_get_imports(memory) {
|
|
|
794
820
|
const ret = Math.random();
|
|
795
821
|
return ret;
|
|
796
822
|
},
|
|
797
|
-
|
|
798
|
-
const ret = arg0.removeEntry(getStringFromWasm0(arg1, arg2)
|
|
823
|
+
__wbg_removeEntry_5200c020554eef5e: function(arg0, arg1, arg2) {
|
|
824
|
+
const ret = arg0.removeEntry(getStringFromWasm0(arg1, arg2));
|
|
799
825
|
return ret;
|
|
800
826
|
},
|
|
801
|
-
|
|
802
|
-
const ret = arg0.removeEntry(getStringFromWasm0(arg1, arg2));
|
|
827
|
+
__wbg_removeEntry_b0e58a242da8a1cf: function(arg0, arg1, arg2, arg3) {
|
|
828
|
+
const ret = arg0.removeEntry(getStringFromWasm0(arg1, arg2), arg3);
|
|
803
829
|
return ret;
|
|
804
830
|
},
|
|
805
831
|
__wbg_rendering_new: function(arg0) {
|
|
806
832
|
const ret = Rendering.__wrap(arg0);
|
|
807
833
|
return ret;
|
|
808
834
|
},
|
|
809
|
-
|
|
835
|
+
__wbg_request_eb7cf9d79f2b866e: function(arg0, arg1, arg2, arg3) {
|
|
810
836
|
const ret = arg0.request(getStringFromWasm0(arg1, arg2), arg3);
|
|
811
837
|
return ret;
|
|
812
838
|
},
|
|
@@ -821,23 +847,23 @@ function __wbg_get_imports(memory) {
|
|
|
821
847
|
__wbg_set_c41f8dbc07a2190f: function(arg0, arg1, arg2) {
|
|
822
848
|
arg0.set(getArrayF32FromWasm0(arg1, arg2));
|
|
823
849
|
},
|
|
824
|
-
|
|
850
|
+
__wbg_set_name_3d1b37d785401fc2: function(arg0, arg1, arg2) {
|
|
825
851
|
arg0.name = getStringFromWasm0(arg1, arg2);
|
|
826
852
|
},
|
|
827
853
|
__wbg_set_onmessage_2244c2525c4e0c38: function(arg0, arg1) {
|
|
828
854
|
arg0.onmessage = arg1;
|
|
829
855
|
},
|
|
830
|
-
|
|
856
|
+
__wbg_set_onmessage_de3e9b344c2a60e1: function(arg0, arg1) {
|
|
831
857
|
arg0.onmessage = arg1;
|
|
832
858
|
},
|
|
833
|
-
|
|
859
|
+
__wbg_set_refusal_470e7e8a2aa7449c: function(arg0, arg1) {
|
|
834
860
|
arg0.refusal = arg1;
|
|
835
861
|
},
|
|
836
|
-
|
|
862
|
+
__wbg_size_0908d6786bbb6a59: function(arg0) {
|
|
837
863
|
const ret = arg0.size;
|
|
838
864
|
return ret;
|
|
839
865
|
},
|
|
840
|
-
|
|
866
|
+
__wbg_slice_5668c2b391ded9ae: function(arg0, arg1, arg2) {
|
|
841
867
|
const ret = arg0.slice(arg1, arg2);
|
|
842
868
|
return ret;
|
|
843
869
|
},
|
|
@@ -897,35 +923,35 @@ function __wbg_get_imports(memory) {
|
|
|
897
923
|
const ret = Atomics.waitAsync;
|
|
898
924
|
return ret;
|
|
899
925
|
},
|
|
900
|
-
|
|
926
|
+
__wbg_warn_15deab5150b29620: function(arg0, arg1) {
|
|
901
927
|
console.warn(getStringFromWasm0(arg0, arg1));
|
|
902
928
|
},
|
|
903
|
-
|
|
929
|
+
__wbg_write_c4f15f6e0905c5fe: function(arg0, arg1) {
|
|
904
930
|
const ret = arg0.write(arg1);
|
|
905
931
|
return ret;
|
|
906
932
|
},
|
|
907
933
|
__wbindgen_generic_0000000000000001: function(arg0, arg1) {
|
|
908
|
-
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx:
|
|
934
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
909
935
|
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_d3a5247b0aa3f0ac___convert__closures_____invoke___wasm_bindgen_d3a5247b0aa3f0ac___JsValue______true_);
|
|
910
936
|
return ret;
|
|
911
937
|
},
|
|
912
938
|
__wbindgen_generic_0000000000000002: function(arg0, arg1) {
|
|
913
|
-
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx:
|
|
939
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 729, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
|
|
914
940
|
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_d3a5247b0aa3f0ac___convert__closures_____invoke___wasm_bindgen_d3a5247b0aa3f0ac___JsValue__core_ea519e494776717c___result__Result_____wasm_bindgen_d3a5247b0aa3f0ac___JsError___true_);
|
|
915
941
|
return ret;
|
|
916
942
|
},
|
|
917
943
|
__wbindgen_generic_0000000000000003: function(arg0, arg1) {
|
|
918
|
-
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx:
|
|
944
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 731, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
919
945
|
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_d3a5247b0aa3f0ac___convert__closures_____invoke___js_sys_2b088e2931f41c5___futures__task__wait_async_polyfill__MessageEvent______true_);
|
|
920
946
|
return ret;
|
|
921
947
|
},
|
|
922
948
|
__wbindgen_generic_0000000000000004: function(arg0, arg1) {
|
|
923
|
-
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx:
|
|
949
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 4, ret: NamedExternref("Promise<any>"), inner_ret: Some(NamedExternref("Promise<any>")) }, mutable: true }) -> Externref`.
|
|
924
950
|
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_d3a5247b0aa3f0ac___convert__closures_____invoke___js_sys_2b088e2931f41c5___Promise__true_);
|
|
925
951
|
return ret;
|
|
926
952
|
},
|
|
927
953
|
__wbindgen_generic_0000000000000005: function(arg0, arg1) {
|
|
928
|
-
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx:
|
|
954
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 6, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
929
955
|
const ret = makeMutClosure(arg0, arg1, wasm_bindgen_d3a5247b0aa3f0ac___convert__closures_____invoke_______true_);
|
|
930
956
|
return ret;
|
|
931
957
|
},
|
package/sva_wasm_bg.wasm
CHANGED
|
Binary file
|