@almadar/kernel 19.0.0 → 19.0.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.
- package/package.json +1 -1
- package/pkg/orbital_wasm.d.ts +79 -8
- package/pkg/orbital_wasm.js +1593 -173
- package/pkg/orbital_wasm_bg.wasm +0 -0
- package/pkg/orbital_wasm_bg.wasm.d.ts +44 -5
- package/pkg-client/orbital_wasm.d.ts +79 -8
- package/pkg-client/orbital_wasm.js +1593 -173
- package/pkg-client/orbital_wasm_bg.wasm +0 -0
- package/pkg-client/orbital_wasm_bg.wasm.d.ts +44 -5
|
@@ -609,11 +609,12 @@ export class Kernel {
|
|
|
609
609
|
* @param {string} seeds_json
|
|
610
610
|
* @param {string | null} [entity_id]
|
|
611
611
|
* @param {string | null} [payload_json]
|
|
612
|
+
* @param {string | null} [route]
|
|
612
613
|
* @returns {string}
|
|
613
614
|
*/
|
|
614
|
-
dispatchMount(seeds_json, entity_id, payload_json) {
|
|
615
|
-
let
|
|
616
|
-
let
|
|
615
|
+
dispatchMount(seeds_json, entity_id, payload_json, route) {
|
|
616
|
+
let deferred6_0;
|
|
617
|
+
let deferred6_1;
|
|
617
618
|
try {
|
|
618
619
|
const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
619
620
|
const len0 = WASM_VECTOR_LEN;
|
|
@@ -621,18 +622,20 @@ export class Kernel {
|
|
|
621
622
|
var len1 = WASM_VECTOR_LEN;
|
|
622
623
|
var ptr2 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
623
624
|
var len2 = WASM_VECTOR_LEN;
|
|
624
|
-
|
|
625
|
-
var
|
|
626
|
-
|
|
625
|
+
var ptr3 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
626
|
+
var len3 = WASM_VECTOR_LEN;
|
|
627
|
+
const ret = wasm.kernel_dispatchMount(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
|
|
628
|
+
var ptr5 = ret[0];
|
|
629
|
+
var len5 = ret[1];
|
|
627
630
|
if (ret[3]) {
|
|
628
|
-
|
|
631
|
+
ptr5 = 0; len5 = 0;
|
|
629
632
|
throw takeFromExternrefTable0(ret[2]);
|
|
630
633
|
}
|
|
631
|
-
|
|
632
|
-
|
|
633
|
-
return getStringFromWasm0(
|
|
634
|
+
deferred6_0 = ptr5;
|
|
635
|
+
deferred6_1 = len5;
|
|
636
|
+
return getStringFromWasm0(ptr5, len5);
|
|
634
637
|
} finally {
|
|
635
|
-
wasm.__wbindgen_free(
|
|
638
|
+
wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
|
|
636
639
|
}
|
|
637
640
|
}
|
|
638
641
|
/**
|
|
@@ -1079,20 +1082,6 @@ export class Kernel {
|
|
|
1079
1082
|
setHostFansOut(fans_out) {
|
|
1080
1083
|
wasm.kernel_setHostFansOut(this.__wbg_ptr, fans_out);
|
|
1081
1084
|
}
|
|
1082
|
-
/**
|
|
1083
|
-
* @param {string} locales_json
|
|
1084
|
-
* @param {string} catalogs_json
|
|
1085
|
-
*/
|
|
1086
|
-
setMessages(locales_json, catalogs_json) {
|
|
1087
|
-
const ptr0 = passStringToWasm0(locales_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1088
|
-
const len0 = WASM_VECTOR_LEN;
|
|
1089
|
-
const ptr1 = passStringToWasm0(catalogs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1090
|
-
const len1 = WASM_VECTOR_LEN;
|
|
1091
|
-
const ret = wasm.kernel_setMessages(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
1092
|
-
if (ret[1]) {
|
|
1093
|
-
throw takeFromExternrefTable0(ret[0]);
|
|
1094
|
-
}
|
|
1095
|
-
}
|
|
1096
1085
|
/**
|
|
1097
1086
|
* Carry each hop's `@entity` before and after it on the dispatch's transitions (`observed`), for a verifier
|
|
1098
1087
|
* judging `@ensures`. Off by default (EXEC-STEP-10).
|
|
@@ -1112,6 +1101,13 @@ export class Kernel {
|
|
|
1112
1101
|
throw takeFromExternrefTable0(ret[0]);
|
|
1113
1102
|
}
|
|
1114
1103
|
}
|
|
1104
|
+
/**
|
|
1105
|
+
* Record each dispatch as a trace item while on, for the host's `program/live { kind: "trace" }` streams.
|
|
1106
|
+
* @param {boolean} on
|
|
1107
|
+
*/
|
|
1108
|
+
setTraceOn(on) {
|
|
1109
|
+
wasm.kernel_setTraceOn(this.__wbg_ptr, on);
|
|
1110
|
+
}
|
|
1115
1111
|
/**
|
|
1116
1112
|
* The host's report of whether a trait's rendered output is on screen; gates its `[visible]` ticks.
|
|
1117
1113
|
* @param {string} trait_name
|
|
@@ -1122,6 +1118,18 @@ export class Kernel {
|
|
|
1122
1118
|
const len0 = WASM_VECTOR_LEN;
|
|
1123
1119
|
wasm.kernel_setTraitOnScreen(this.__wbg_ptr, ptr0, len0, on_screen);
|
|
1124
1120
|
}
|
|
1121
|
+
/**
|
|
1122
|
+
* The page's locale `i18n/t` paints in when a dispatch names none; the program carries its own messages.
|
|
1123
|
+
* @param {string | null} [locale]
|
|
1124
|
+
*/
|
|
1125
|
+
setViewerLocale(locale) {
|
|
1126
|
+
var ptr0 = isLikeNone(locale) ? 0 : passStringToWasm0(locale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
1127
|
+
var len0 = WASM_VECTOR_LEN;
|
|
1128
|
+
const ret = wasm.kernel_setViewerLocale(this.__wbg_ptr, ptr0, len0);
|
|
1129
|
+
if (ret[1]) {
|
|
1130
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
1131
|
+
}
|
|
1132
|
+
}
|
|
1125
1133
|
/**
|
|
1126
1134
|
* @returns {string}
|
|
1127
1135
|
*/
|
|
@@ -1167,6 +1175,28 @@ export class Kernel {
|
|
|
1167
1175
|
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
1168
1176
|
}
|
|
1169
1177
|
}
|
|
1178
|
+
/**
|
|
1179
|
+
* The trace items recorded since the last take, in dispatch order: a JSON array.
|
|
1180
|
+
* @returns {string}
|
|
1181
|
+
*/
|
|
1182
|
+
takeTrace() {
|
|
1183
|
+
let deferred2_0;
|
|
1184
|
+
let deferred2_1;
|
|
1185
|
+
try {
|
|
1186
|
+
const ret = wasm.kernel_takeTrace(this.__wbg_ptr);
|
|
1187
|
+
var ptr1 = ret[0];
|
|
1188
|
+
var len1 = ret[1];
|
|
1189
|
+
if (ret[3]) {
|
|
1190
|
+
ptr1 = 0; len1 = 0;
|
|
1191
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
1192
|
+
}
|
|
1193
|
+
deferred2_0 = ptr1;
|
|
1194
|
+
deferred2_1 = len1;
|
|
1195
|
+
return getStringFromWasm0(ptr1, len1);
|
|
1196
|
+
} finally {
|
|
1197
|
+
wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
|
|
1198
|
+
}
|
|
1199
|
+
}
|
|
1170
1200
|
/**
|
|
1171
1201
|
* @param {string} trait_name
|
|
1172
1202
|
* @param {string} tick_name
|
|
@@ -2142,20 +2172,6 @@ export class Server {
|
|
|
2142
2172
|
throw takeFromExternrefTable0(ret[0]);
|
|
2143
2173
|
}
|
|
2144
2174
|
}
|
|
2145
|
-
/**
|
|
2146
|
-
* @param {string} locales_json
|
|
2147
|
-
* @param {string} catalogs_json
|
|
2148
|
-
*/
|
|
2149
|
-
setMessages(locales_json, catalogs_json) {
|
|
2150
|
-
const ptr0 = passStringToWasm0(locales_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2151
|
-
const len0 = WASM_VECTOR_LEN;
|
|
2152
|
-
const ptr1 = passStringToWasm0(catalogs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2153
|
-
const len1 = WASM_VECTOR_LEN;
|
|
2154
|
-
const ret = wasm.server_setMessages(this.__wbg_ptr, ptr0, len0, ptr1, len1);
|
|
2155
|
-
if (ret[1]) {
|
|
2156
|
-
throw takeFromExternrefTable0(ret[0]);
|
|
2157
|
-
}
|
|
2158
|
-
}
|
|
2159
2175
|
/**
|
|
2160
2176
|
* @param {string} anchors_json
|
|
2161
2177
|
* @returns {string}
|
|
@@ -2481,6 +2497,75 @@ export function eventWires(schema_json) {
|
|
|
2481
2497
|
}
|
|
2482
2498
|
}
|
|
2483
2499
|
|
|
2500
|
+
/**
|
|
2501
|
+
* @param {string} layer_json
|
|
2502
|
+
* @param {number} epoch_now_ms
|
|
2503
|
+
* @param {string} dimension
|
|
2504
|
+
* @param {number} tile_width
|
|
2505
|
+
* @returns {string}
|
|
2506
|
+
*/
|
|
2507
|
+
export function expandFxLayer(layer_json, epoch_now_ms, dimension, tile_width) {
|
|
2508
|
+
let deferred4_0;
|
|
2509
|
+
let deferred4_1;
|
|
2510
|
+
try {
|
|
2511
|
+
const ptr0 = passStringToWasm0(layer_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2512
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2513
|
+
const ptr1 = passStringToWasm0(dimension, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2514
|
+
const len1 = WASM_VECTOR_LEN;
|
|
2515
|
+
const ret = wasm.expandFxLayer(ptr0, len0, epoch_now_ms, ptr1, len1, tile_width);
|
|
2516
|
+
var ptr3 = ret[0];
|
|
2517
|
+
var len3 = ret[1];
|
|
2518
|
+
if (ret[3]) {
|
|
2519
|
+
ptr3 = 0; len3 = 0;
|
|
2520
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2521
|
+
}
|
|
2522
|
+
deferred4_0 = ptr3;
|
|
2523
|
+
deferred4_1 = len3;
|
|
2524
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2525
|
+
} finally {
|
|
2526
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2527
|
+
}
|
|
2528
|
+
}
|
|
2529
|
+
|
|
2530
|
+
/**
|
|
2531
|
+
* @param {string} seed
|
|
2532
|
+
* @param {number} salt
|
|
2533
|
+
* @returns {number}
|
|
2534
|
+
*/
|
|
2535
|
+
export function fxHash01(seed, salt) {
|
|
2536
|
+
const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2537
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2538
|
+
const ret = wasm.fxHash01(ptr0, len0, salt);
|
|
2539
|
+
return ret;
|
|
2540
|
+
}
|
|
2541
|
+
|
|
2542
|
+
/**
|
|
2543
|
+
* @param {string} view_json
|
|
2544
|
+
* @param {number} epoch_now_ms
|
|
2545
|
+
* @param {number} tick_ms
|
|
2546
|
+
* @returns {string}
|
|
2547
|
+
*/
|
|
2548
|
+
export function fxLifecycle(view_json, epoch_now_ms, tick_ms) {
|
|
2549
|
+
let deferred3_0;
|
|
2550
|
+
let deferred3_1;
|
|
2551
|
+
try {
|
|
2552
|
+
const ptr0 = passStringToWasm0(view_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2553
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2554
|
+
const ret = wasm.fxLifecycle(ptr0, len0, epoch_now_ms, tick_ms);
|
|
2555
|
+
var ptr2 = ret[0];
|
|
2556
|
+
var len2 = ret[1];
|
|
2557
|
+
if (ret[3]) {
|
|
2558
|
+
ptr2 = 0; len2 = 0;
|
|
2559
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2560
|
+
}
|
|
2561
|
+
deferred3_0 = ptr2;
|
|
2562
|
+
deferred3_1 = len2;
|
|
2563
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2564
|
+
} finally {
|
|
2565
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2566
|
+
}
|
|
2567
|
+
}
|
|
2568
|
+
|
|
2484
2569
|
/**
|
|
2485
2570
|
* Install the language data a host assembles from its installed `@almadar/core` and `@almadar/std`
|
|
2486
2571
|
* (`readLanguageBundle`): the operator table that routes `program/*` and the other host effects.
|
|
@@ -2652,6 +2737,34 @@ export function report_panics() {
|
|
|
2652
2737
|
wasm.report_panics();
|
|
2653
2738
|
}
|
|
2654
2739
|
|
|
2740
|
+
/**
|
|
2741
|
+
* @param {string} item_json
|
|
2742
|
+
* @param {string | null} [presets_json]
|
|
2743
|
+
* @returns {string}
|
|
2744
|
+
*/
|
|
2745
|
+
export function resolveFxView(item_json, presets_json) {
|
|
2746
|
+
let deferred4_0;
|
|
2747
|
+
let deferred4_1;
|
|
2748
|
+
try {
|
|
2749
|
+
const ptr0 = passStringToWasm0(item_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2750
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2751
|
+
var ptr1 = isLikeNone(presets_json) ? 0 : passStringToWasm0(presets_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2752
|
+
var len1 = WASM_VECTOR_LEN;
|
|
2753
|
+
const ret = wasm.resolveFxView(ptr0, len0, ptr1, len1);
|
|
2754
|
+
var ptr3 = ret[0];
|
|
2755
|
+
var len3 = ret[1];
|
|
2756
|
+
if (ret[3]) {
|
|
2757
|
+
ptr3 = 0; len3 = 0;
|
|
2758
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2759
|
+
}
|
|
2760
|
+
deferred4_0 = ptr3;
|
|
2761
|
+
deferred4_1 = len3;
|
|
2762
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2763
|
+
} finally {
|
|
2764
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2765
|
+
}
|
|
2766
|
+
}
|
|
2767
|
+
|
|
2655
2768
|
/**
|
|
2656
2769
|
* What a `@user`/`@payload`/`@config`/`@now` term folds to for a row predicate (`RowBindingWire` as JSON).
|
|
2657
2770
|
* @param {string} term
|
|
@@ -2750,72 +2863,100 @@ export function scopeRows(bindings_json, rows_json, policy_json, filter_json, en
|
|
|
2750
2863
|
}
|
|
2751
2864
|
|
|
2752
2865
|
/**
|
|
2753
|
-
* @param {string}
|
|
2754
|
-
* @param {
|
|
2755
|
-
* @param {
|
|
2756
|
-
* @param {string} args_json
|
|
2757
|
-
* @param {string} outcome_json
|
|
2866
|
+
* @param {string} matrix_json
|
|
2867
|
+
* @param {number} x
|
|
2868
|
+
* @param {number} y
|
|
2758
2869
|
* @returns {string}
|
|
2759
2870
|
*/
|
|
2760
|
-
export function
|
|
2761
|
-
let
|
|
2762
|
-
let
|
|
2871
|
+
export function skinApplyAffine(matrix_json, x, y) {
|
|
2872
|
+
let deferred3_0;
|
|
2873
|
+
let deferred3_1;
|
|
2763
2874
|
try {
|
|
2764
|
-
const ptr0 = passStringToWasm0(
|
|
2875
|
+
const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2765
2876
|
const len0 = WASM_VECTOR_LEN;
|
|
2766
|
-
const
|
|
2877
|
+
const ret = wasm.skinApplyAffine(ptr0, len0, x, y);
|
|
2878
|
+
var ptr2 = ret[0];
|
|
2879
|
+
var len2 = ret[1];
|
|
2880
|
+
if (ret[3]) {
|
|
2881
|
+
ptr2 = 0; len2 = 0;
|
|
2882
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2883
|
+
}
|
|
2884
|
+
deferred3_0 = ptr2;
|
|
2885
|
+
deferred3_1 = len2;
|
|
2886
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2887
|
+
} finally {
|
|
2888
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2889
|
+
}
|
|
2890
|
+
}
|
|
2891
|
+
|
|
2892
|
+
/**
|
|
2893
|
+
* @param {string} a_json
|
|
2894
|
+
* @param {string} b_json
|
|
2895
|
+
* @returns {string}
|
|
2896
|
+
*/
|
|
2897
|
+
export function skinComposeAffine(a_json, b_json) {
|
|
2898
|
+
let deferred4_0;
|
|
2899
|
+
let deferred4_1;
|
|
2900
|
+
try {
|
|
2901
|
+
const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2902
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2903
|
+
const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2767
2904
|
const len1 = WASM_VECTOR_LEN;
|
|
2768
|
-
const
|
|
2769
|
-
|
|
2770
|
-
|
|
2771
|
-
const len3 = WASM_VECTOR_LEN;
|
|
2772
|
-
const ptr4 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2773
|
-
const len4 = WASM_VECTOR_LEN;
|
|
2774
|
-
const ret = wasm.substrateCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
|
|
2775
|
-
var ptr6 = ret[0];
|
|
2776
|
-
var len6 = ret[1];
|
|
2905
|
+
const ret = wasm.skinComposeAffine(ptr0, len0, ptr1, len1);
|
|
2906
|
+
var ptr3 = ret[0];
|
|
2907
|
+
var len3 = ret[1];
|
|
2777
2908
|
if (ret[3]) {
|
|
2778
|
-
|
|
2909
|
+
ptr3 = 0; len3 = 0;
|
|
2779
2910
|
throw takeFromExternrefTable0(ret[2]);
|
|
2780
2911
|
}
|
|
2781
|
-
|
|
2782
|
-
|
|
2783
|
-
return getStringFromWasm0(
|
|
2912
|
+
deferred4_0 = ptr3;
|
|
2913
|
+
deferred4_1 = len3;
|
|
2914
|
+
return getStringFromWasm0(ptr3, len3);
|
|
2784
2915
|
} finally {
|
|
2785
|
-
wasm.__wbindgen_free(
|
|
2916
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
2786
2917
|
}
|
|
2787
2918
|
}
|
|
2788
2919
|
|
|
2789
2920
|
/**
|
|
2790
|
-
*
|
|
2791
|
-
* @param {
|
|
2792
|
-
* @
|
|
2793
|
-
* @returns {boolean}
|
|
2921
|
+
* @param {string} matrix_json
|
|
2922
|
+
* @param {number} bone
|
|
2923
|
+
* @returns {string}
|
|
2794
2924
|
*/
|
|
2795
|
-
export function
|
|
2796
|
-
|
|
2797
|
-
|
|
2798
|
-
|
|
2799
|
-
|
|
2800
|
-
|
|
2801
|
-
|
|
2925
|
+
export function skinInvertAffine(matrix_json, bone) {
|
|
2926
|
+
let deferred3_0;
|
|
2927
|
+
let deferred3_1;
|
|
2928
|
+
try {
|
|
2929
|
+
const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2930
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2931
|
+
const ret = wasm.skinInvertAffine(ptr0, len0, bone);
|
|
2932
|
+
var ptr2 = ret[0];
|
|
2933
|
+
var len2 = ret[1];
|
|
2934
|
+
if (ret[3]) {
|
|
2935
|
+
ptr2 = 0; len2 = 0;
|
|
2936
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2937
|
+
}
|
|
2938
|
+
deferred3_0 = ptr2;
|
|
2939
|
+
deferred3_1 = len2;
|
|
2940
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2941
|
+
} finally {
|
|
2942
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2943
|
+
}
|
|
2802
2944
|
}
|
|
2803
2945
|
|
|
2804
2946
|
/**
|
|
2805
|
-
*
|
|
2806
|
-
* @param {string}
|
|
2807
|
-
* @param {string} effects_json
|
|
2947
|
+
* @param {string} src_json
|
|
2948
|
+
* @param {string} dst_json
|
|
2808
2949
|
* @returns {string}
|
|
2809
2950
|
*/
|
|
2810
|
-
export function
|
|
2951
|
+
export function skinTriangleAffine(src_json, dst_json) {
|
|
2811
2952
|
let deferred4_0;
|
|
2812
2953
|
let deferred4_1;
|
|
2813
2954
|
try {
|
|
2814
|
-
const ptr0 = passStringToWasm0(
|
|
2955
|
+
const ptr0 = passStringToWasm0(src_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2815
2956
|
const len0 = WASM_VECTOR_LEN;
|
|
2816
|
-
const ptr1 = passStringToWasm0(
|
|
2957
|
+
const ptr1 = passStringToWasm0(dst_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2817
2958
|
const len1 = WASM_VECTOR_LEN;
|
|
2818
|
-
const ret = wasm.
|
|
2959
|
+
const ret = wasm.skinTriangleAffine(ptr0, len0, ptr1, len1);
|
|
2819
2960
|
var ptr3 = ret[0];
|
|
2820
2961
|
var len3 = ret[1];
|
|
2821
2962
|
if (ret[3]) {
|
|
@@ -2831,124 +2972,1158 @@ export function traceEffects(context_json, effects_json) {
|
|
|
2831
2972
|
}
|
|
2832
2973
|
|
|
2833
2974
|
/**
|
|
2834
|
-
*
|
|
2835
|
-
* @
|
|
2975
|
+
* @param {string} points_json
|
|
2976
|
+
* @returns {string}
|
|
2836
2977
|
*/
|
|
2837
|
-
export function
|
|
2838
|
-
|
|
2839
|
-
|
|
2840
|
-
|
|
2841
|
-
|
|
2842
|
-
|
|
2978
|
+
export function skinVertexBounds(points_json) {
|
|
2979
|
+
let deferred3_0;
|
|
2980
|
+
let deferred3_1;
|
|
2981
|
+
try {
|
|
2982
|
+
const ptr0 = passStringToWasm0(points_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
2983
|
+
const len0 = WASM_VECTOR_LEN;
|
|
2984
|
+
const ret = wasm.skinVertexBounds(ptr0, len0);
|
|
2985
|
+
var ptr2 = ret[0];
|
|
2986
|
+
var len2 = ret[1];
|
|
2987
|
+
if (ret[3]) {
|
|
2988
|
+
ptr2 = 0; len2 = 0;
|
|
2989
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
2990
|
+
}
|
|
2991
|
+
deferred3_0 = ptr2;
|
|
2992
|
+
deferred3_1 = len2;
|
|
2993
|
+
return getStringFromWasm0(ptr2, len2);
|
|
2994
|
+
} finally {
|
|
2995
|
+
wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
|
|
2843
2996
|
}
|
|
2844
2997
|
}
|
|
2845
|
-
|
|
2846
|
-
|
|
2847
|
-
|
|
2848
|
-
|
|
2849
|
-
|
|
2850
|
-
|
|
2851
|
-
|
|
2998
|
+
|
|
2999
|
+
/**
|
|
3000
|
+
* @param {string} mesh_json
|
|
3001
|
+
* @param {string} bind_json
|
|
3002
|
+
* @param {string} current_json
|
|
3003
|
+
* @returns {string}
|
|
3004
|
+
*/
|
|
3005
|
+
export function skinVertices(mesh_json, bind_json, current_json) {
|
|
3006
|
+
let deferred5_0;
|
|
3007
|
+
let deferred5_1;
|
|
3008
|
+
try {
|
|
3009
|
+
const ptr0 = passStringToWasm0(mesh_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3010
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3011
|
+
const ptr1 = passStringToWasm0(bind_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3012
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3013
|
+
const ptr2 = passStringToWasm0(current_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3014
|
+
const len2 = WASM_VECTOR_LEN;
|
|
3015
|
+
const ret = wasm.skinVertices(ptr0, len0, ptr1, len1, ptr2, len2);
|
|
3016
|
+
var ptr4 = ret[0];
|
|
3017
|
+
var len4 = ret[1];
|
|
3018
|
+
if (ret[3]) {
|
|
3019
|
+
ptr4 = 0; len4 = 0;
|
|
3020
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3021
|
+
}
|
|
3022
|
+
deferred5_0 = ptr4;
|
|
3023
|
+
deferred5_1 = len4;
|
|
3024
|
+
return getStringFromWasm0(ptr4, len4);
|
|
3025
|
+
} finally {
|
|
3026
|
+
wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
|
|
3027
|
+
}
|
|
3028
|
+
}
|
|
3029
|
+
|
|
3030
|
+
/**
|
|
3031
|
+
* @param {string} bones_json
|
|
3032
|
+
* @param {string} pose_json
|
|
3033
|
+
* @returns {string}
|
|
3034
|
+
*/
|
|
3035
|
+
export function skinWorldMatrices(bones_json, pose_json) {
|
|
3036
|
+
let deferred4_0;
|
|
3037
|
+
let deferred4_1;
|
|
3038
|
+
try {
|
|
3039
|
+
const ptr0 = passStringToWasm0(bones_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3040
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3041
|
+
const ptr1 = passStringToWasm0(pose_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3042
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3043
|
+
const ret = wasm.skinWorldMatrices(ptr0, len0, ptr1, len1);
|
|
3044
|
+
var ptr3 = ret[0];
|
|
3045
|
+
var len3 = ret[1];
|
|
3046
|
+
if (ret[3]) {
|
|
3047
|
+
ptr3 = 0; len3 = 0;
|
|
3048
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3049
|
+
}
|
|
3050
|
+
deferred4_0 = ptr3;
|
|
3051
|
+
deferred4_1 = len3;
|
|
3052
|
+
return getStringFromWasm0(ptr3, len3);
|
|
3053
|
+
} finally {
|
|
3054
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3055
|
+
}
|
|
3056
|
+
}
|
|
3057
|
+
|
|
3058
|
+
/**
|
|
3059
|
+
* @param {string} site_json
|
|
3060
|
+
* @param {string} key
|
|
3061
|
+
* @param {string} op
|
|
3062
|
+
* @param {string} args_json
|
|
3063
|
+
* @param {string} outcome_json
|
|
3064
|
+
* @returns {string}
|
|
3065
|
+
*/
|
|
3066
|
+
export function substrateCompletionEvent(site_json, key, op, args_json, outcome_json) {
|
|
3067
|
+
let deferred7_0;
|
|
3068
|
+
let deferred7_1;
|
|
3069
|
+
try {
|
|
3070
|
+
const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3071
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3072
|
+
const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3073
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3074
|
+
const ptr2 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3075
|
+
const len2 = WASM_VECTOR_LEN;
|
|
3076
|
+
const ptr3 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3077
|
+
const len3 = WASM_VECTOR_LEN;
|
|
3078
|
+
const ptr4 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3079
|
+
const len4 = WASM_VECTOR_LEN;
|
|
3080
|
+
const ret = wasm.substrateCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
|
|
3081
|
+
var ptr6 = ret[0];
|
|
3082
|
+
var len6 = ret[1];
|
|
3083
|
+
if (ret[3]) {
|
|
3084
|
+
ptr6 = 0; len6 = 0;
|
|
3085
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3086
|
+
}
|
|
3087
|
+
deferred7_0 = ptr6;
|
|
3088
|
+
deferred7_1 = len6;
|
|
3089
|
+
return getStringFromWasm0(ptr6, len6);
|
|
3090
|
+
} finally {
|
|
3091
|
+
wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
|
|
3092
|
+
}
|
|
3093
|
+
}
|
|
3094
|
+
|
|
3095
|
+
/**
|
|
3096
|
+
* Whether the Chrome match pattern `pattern` matches `url`.
|
|
3097
|
+
* @param {string} pattern
|
|
3098
|
+
* @param {string} url
|
|
3099
|
+
* @returns {boolean}
|
|
3100
|
+
*/
|
|
3101
|
+
export function tabUrlMatches(pattern, url) {
|
|
3102
|
+
const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3103
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3104
|
+
const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3105
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3106
|
+
const ret = wasm.tabUrlMatches(ptr0, len0, ptr1, len1);
|
|
3107
|
+
return ret !== 0;
|
|
3108
|
+
}
|
|
3109
|
+
|
|
3110
|
+
/**
|
|
3111
|
+
* Effects run in order against a row (`TraceEffectsWire` as JSON): a trace per effect, the events raised, the writes made.
|
|
3112
|
+
* @param {string} context_json
|
|
3113
|
+
* @param {string} effects_json
|
|
3114
|
+
* @returns {string}
|
|
3115
|
+
*/
|
|
3116
|
+
export function traceEffects(context_json, effects_json) {
|
|
3117
|
+
let deferred4_0;
|
|
3118
|
+
let deferred4_1;
|
|
3119
|
+
try {
|
|
3120
|
+
const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3121
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3122
|
+
const ptr1 = passStringToWasm0(effects_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3123
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3124
|
+
const ret = wasm.traceEffects(ptr0, len0, ptr1, len1);
|
|
3125
|
+
var ptr3 = ret[0];
|
|
3126
|
+
var len3 = ret[1];
|
|
3127
|
+
if (ret[3]) {
|
|
3128
|
+
ptr3 = 0; len3 = 0;
|
|
3129
|
+
throw takeFromExternrefTable0(ret[2]);
|
|
3130
|
+
}
|
|
3131
|
+
deferred4_0 = ptr3;
|
|
3132
|
+
deferred4_1 = len3;
|
|
3133
|
+
return getStringFromWasm0(ptr3, len3);
|
|
3134
|
+
} finally {
|
|
3135
|
+
wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
|
|
3136
|
+
}
|
|
3137
|
+
}
|
|
3138
|
+
|
|
3139
|
+
/**
|
|
3140
|
+
* The kernel's verdict on language packs (`[{ package, definition }]` as JSON): throws the refusal that names each pack, section and word.
|
|
3141
|
+
* @param {string} packs_json
|
|
3142
|
+
*/
|
|
3143
|
+
export function validatePacks(packs_json) {
|
|
3144
|
+
const ptr0 = passStringToWasm0(packs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3145
|
+
const len0 = WASM_VECTOR_LEN;
|
|
3146
|
+
const ret = wasm.validatePacks(ptr0, len0);
|
|
3147
|
+
if (ret[1]) {
|
|
3148
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
3149
|
+
}
|
|
3150
|
+
}
|
|
3151
|
+
function __wbg_get_imports() {
|
|
3152
|
+
const import0 = {
|
|
3153
|
+
__proto__: null,
|
|
3154
|
+
__wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
|
|
3155
|
+
const ret = Error(getStringFromWasm0(arg0, arg1));
|
|
3156
|
+
return ret;
|
|
3157
|
+
},
|
|
3158
|
+
__wbg_Window_defb2c76b3875a73: function(arg0) {
|
|
3159
|
+
const ret = arg0.Window;
|
|
3160
|
+
return ret;
|
|
3161
|
+
},
|
|
3162
|
+
__wbg_WorkerGlobalScope_184e45d6565eb3f0: function(arg0) {
|
|
3163
|
+
const ret = arg0.WorkerGlobalScope;
|
|
3164
|
+
return ret;
|
|
3165
|
+
},
|
|
3166
|
+
__wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
|
|
3167
|
+
const ret = debugString(arg1);
|
|
3168
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3169
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3170
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3171
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3172
|
+
},
|
|
2852
3173
|
__wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
|
|
2853
3174
|
const ret = typeof(arg0) === 'function';
|
|
2854
3175
|
return ret;
|
|
2855
3176
|
},
|
|
2856
|
-
|
|
2857
|
-
const
|
|
2858
|
-
|
|
2859
|
-
|
|
3177
|
+
__wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
|
|
3178
|
+
const ret = arg0 === null;
|
|
3179
|
+
return ret;
|
|
3180
|
+
},
|
|
3181
|
+
__wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
|
|
3182
|
+
const val = arg0;
|
|
3183
|
+
const ret = typeof(val) === 'object' && val !== null;
|
|
3184
|
+
return ret;
|
|
3185
|
+
},
|
|
3186
|
+
__wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
|
|
3187
|
+
const ret = typeof(arg0) === 'string';
|
|
3188
|
+
return ret;
|
|
3189
|
+
},
|
|
3190
|
+
__wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
|
|
3191
|
+
const ret = arg0 === undefined;
|
|
3192
|
+
return ret;
|
|
3193
|
+
},
|
|
3194
|
+
__wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
|
|
3195
|
+
throw new Error(getStringFromWasm0(arg0, arg1));
|
|
3196
|
+
},
|
|
3197
|
+
__wbg__wbg_cb_unref_fffb441def202758: function(arg0) {
|
|
3198
|
+
arg0._wbg_cb_unref();
|
|
3199
|
+
},
|
|
3200
|
+
__wbg_arrayBuffer_3b637f0fa65c5351: function() { return handleError(function (arg0) {
|
|
3201
|
+
const ret = arg0.arrayBuffer();
|
|
3202
|
+
return ret;
|
|
3203
|
+
}, arguments); },
|
|
3204
|
+
__wbg_beginRenderPass_8f60a9940800c223: function() { return handleError(function (arg0, arg1) {
|
|
3205
|
+
const ret = arg0.beginRenderPass(arg1);
|
|
3206
|
+
return ret;
|
|
3207
|
+
}, arguments); },
|
|
3208
|
+
__wbg_buffer_54b87055582c8a81: function(arg0) {
|
|
3209
|
+
const ret = arg0.buffer;
|
|
3210
|
+
return ret;
|
|
3211
|
+
},
|
|
3212
|
+
__wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
|
|
3213
|
+
const ret = arg0.call(arg1, arg2);
|
|
3214
|
+
return ret;
|
|
3215
|
+
}, arguments); },
|
|
3216
|
+
__wbg_configure_6e4ddb3faabc6005: function() { return handleError(function (arg0, arg1) {
|
|
3217
|
+
arg0.configure(arg1);
|
|
3218
|
+
}, arguments); },
|
|
3219
|
+
__wbg_copyTextureToBuffer_09ba100a04b1b001: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
3220
|
+
arg0.copyTextureToBuffer(arg1, arg2, arg3);
|
|
3221
|
+
}, arguments); },
|
|
3222
|
+
__wbg_createBindGroupLayout_1dad97f44fda2929: function() { return handleError(function (arg0, arg1) {
|
|
3223
|
+
const ret = arg0.createBindGroupLayout(arg1);
|
|
3224
|
+
return ret;
|
|
3225
|
+
}, arguments); },
|
|
3226
|
+
__wbg_createBindGroup_0ee0646375643dfb: function(arg0, arg1) {
|
|
3227
|
+
const ret = arg0.createBindGroup(arg1);
|
|
3228
|
+
return ret;
|
|
3229
|
+
},
|
|
3230
|
+
__wbg_createBuffer_474baee88e74f68a: function() { return handleError(function (arg0, arg1) {
|
|
3231
|
+
const ret = arg0.createBuffer(arg1);
|
|
3232
|
+
return ret;
|
|
3233
|
+
}, arguments); },
|
|
3234
|
+
__wbg_createCommandEncoder_5229e112300218b4: function(arg0, arg1) {
|
|
3235
|
+
const ret = arg0.createCommandEncoder(arg1);
|
|
3236
|
+
return ret;
|
|
3237
|
+
},
|
|
3238
|
+
__wbg_createPipelineLayout_bf0deba7918ca157: function(arg0, arg1) {
|
|
3239
|
+
const ret = arg0.createPipelineLayout(arg1);
|
|
3240
|
+
return ret;
|
|
3241
|
+
},
|
|
3242
|
+
__wbg_createRenderPipeline_7baf812b1e7e39e8: function() { return handleError(function (arg0, arg1) {
|
|
3243
|
+
const ret = arg0.createRenderPipeline(arg1);
|
|
3244
|
+
return ret;
|
|
3245
|
+
}, arguments); },
|
|
3246
|
+
__wbg_createSampler_5970d585f322df95: function(arg0, arg1) {
|
|
3247
|
+
const ret = arg0.createSampler(arg1);
|
|
3248
|
+
return ret;
|
|
3249
|
+
},
|
|
3250
|
+
__wbg_createShaderModule_744311a1dd685c14: function(arg0, arg1) {
|
|
3251
|
+
const ret = arg0.createShaderModule(arg1);
|
|
3252
|
+
return ret;
|
|
3253
|
+
},
|
|
3254
|
+
__wbg_createTexture_f357c38256411287: function() { return handleError(function (arg0, arg1) {
|
|
3255
|
+
const ret = arg0.createTexture(arg1);
|
|
3256
|
+
return ret;
|
|
3257
|
+
}, arguments); },
|
|
3258
|
+
__wbg_createView_e7a36ec95c4190f3: function() { return handleError(function (arg0, arg1) {
|
|
3259
|
+
const ret = arg0.createView(arg1);
|
|
3260
|
+
return ret;
|
|
3261
|
+
}, arguments); },
|
|
3262
|
+
__wbg_crypto_38df2bab126b63dc: function(arg0) {
|
|
3263
|
+
const ret = arg0.crypto;
|
|
3264
|
+
return ret;
|
|
3265
|
+
},
|
|
3266
|
+
__wbg_draw_b93abd56938fa3b6: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3267
|
+
arg0.draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
|
|
3268
|
+
},
|
|
3269
|
+
__wbg_end_2fdce848e1c526bc: function(arg0) {
|
|
3270
|
+
arg0.end();
|
|
3271
|
+
},
|
|
3272
|
+
__wbg_error_96e899f14d8344a2: function(arg0, arg1) {
|
|
3273
|
+
console.error(getStringFromWasm0(arg0, arg1));
|
|
3274
|
+
},
|
|
3275
|
+
__wbg_fetch_58167e2c1ef32e0a: function(arg0, arg1, arg2) {
|
|
3276
|
+
const ret = arg0.fetch(getStringFromWasm0(arg1, arg2));
|
|
3277
|
+
return ret;
|
|
3278
|
+
},
|
|
3279
|
+
__wbg_finish_7370ad1c0e62b448: function(arg0) {
|
|
3280
|
+
const ret = arg0.finish();
|
|
3281
|
+
return ret;
|
|
3282
|
+
},
|
|
3283
|
+
__wbg_finish_797b32d15bab2338: function(arg0, arg1) {
|
|
3284
|
+
const ret = arg0.finish(arg1);
|
|
3285
|
+
return ret;
|
|
3286
|
+
},
|
|
3287
|
+
__wbg_getCurrentTexture_628ddb7c08d25190: function() { return handleError(function (arg0) {
|
|
3288
|
+
const ret = arg0.getCurrentTexture();
|
|
3289
|
+
return ret;
|
|
3290
|
+
}, arguments); },
|
|
3291
|
+
__wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
|
|
3292
|
+
const ret = arg0.getDate();
|
|
3293
|
+
return ret;
|
|
3294
|
+
},
|
|
3295
|
+
__wbg_getDay_aa318cce5da74c49: function(arg0) {
|
|
3296
|
+
const ret = arg0.getDay();
|
|
3297
|
+
return ret;
|
|
3298
|
+
},
|
|
3299
|
+
__wbg_getFullYear_6af8b229792ae254: function(arg0) {
|
|
3300
|
+
const ret = arg0.getFullYear();
|
|
3301
|
+
return ret;
|
|
3302
|
+
},
|
|
3303
|
+
__wbg_getHours_9f6561095682ce51: function(arg0) {
|
|
3304
|
+
const ret = arg0.getHours();
|
|
3305
|
+
return ret;
|
|
3306
|
+
},
|
|
3307
|
+
__wbg_getMappedRange_9f13d158ba3946fd: function() { return handleError(function (arg0, arg1, arg2) {
|
|
3308
|
+
const ret = arg0.getMappedRange(arg1, arg2);
|
|
3309
|
+
return ret;
|
|
3310
|
+
}, arguments); },
|
|
3311
|
+
__wbg_getMinutes_b0d5cd90bf9b8f22: function(arg0) {
|
|
3312
|
+
const ret = arg0.getMinutes();
|
|
3313
|
+
return ret;
|
|
3314
|
+
},
|
|
3315
|
+
__wbg_getMonth_fffe29d654d5eb69: function(arg0) {
|
|
3316
|
+
const ret = arg0.getMonth();
|
|
3317
|
+
return ret;
|
|
3318
|
+
},
|
|
3319
|
+
__wbg_getPreferredCanvasFormat_a2b6306e828c2f60: function(arg0) {
|
|
3320
|
+
const ret = arg0.getPreferredCanvasFormat();
|
|
3321
|
+
return (__wbindgen_enum_GpuTextureFormat.indexOf(ret) + 1 || 96) - 1;
|
|
3322
|
+
},
|
|
3323
|
+
__wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
|
|
3324
|
+
arg0.getRandomValues(arg1);
|
|
3325
|
+
}, arguments); },
|
|
3326
|
+
__wbg_get_18e0163e38e5048d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
|
|
3327
|
+
const ret = arg1.get(getStringFromWasm0(arg2, arg3));
|
|
3328
|
+
var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3329
|
+
var len1 = WASM_VECTOR_LEN;
|
|
3330
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3331
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3332
|
+
}, arguments); },
|
|
3333
|
+
__wbg_gpu_ac6dc8fb638a26c3: function(arg0) {
|
|
3334
|
+
const ret = arg0.gpu;
|
|
3335
|
+
return ret;
|
|
3336
|
+
},
|
|
3337
|
+
__wbg_headers_cf9c80f30e2a4eff: function(arg0) {
|
|
3338
|
+
const ret = arg0.headers;
|
|
3339
|
+
return ret;
|
|
3340
|
+
},
|
|
3341
|
+
__wbg_instanceof_GpuAdapter_fb230cdccb184887: function(arg0) {
|
|
3342
|
+
let result;
|
|
3343
|
+
try {
|
|
3344
|
+
result = arg0 instanceof GPUAdapter;
|
|
3345
|
+
} catch (_) {
|
|
3346
|
+
result = false;
|
|
3347
|
+
}
|
|
3348
|
+
const ret = result;
|
|
3349
|
+
return ret;
|
|
3350
|
+
},
|
|
3351
|
+
__wbg_instanceof_Response_c8b64b2256f01bec: function(arg0) {
|
|
3352
|
+
let result;
|
|
3353
|
+
try {
|
|
3354
|
+
result = arg0 instanceof Response;
|
|
3355
|
+
} catch (_) {
|
|
3356
|
+
result = false;
|
|
3357
|
+
}
|
|
3358
|
+
const ret = result;
|
|
3359
|
+
return ret;
|
|
3360
|
+
},
|
|
3361
|
+
__wbg_instanceof_Window_05ba1ee4f6781663: function(arg0) {
|
|
3362
|
+
let result;
|
|
3363
|
+
try {
|
|
3364
|
+
result = arg0 instanceof Window;
|
|
3365
|
+
} catch (_) {
|
|
3366
|
+
result = false;
|
|
3367
|
+
}
|
|
3368
|
+
const ret = result;
|
|
3369
|
+
return ret;
|
|
3370
|
+
},
|
|
3371
|
+
__wbg_label_84abde6506fa15b7: function(arg0, arg1) {
|
|
3372
|
+
const ret = arg1.label;
|
|
3373
|
+
const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
|
|
3374
|
+
const len1 = WASM_VECTOR_LEN;
|
|
3375
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
|
|
3376
|
+
getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
|
|
3377
|
+
},
|
|
3378
|
+
__wbg_length_1f0964f4a5e2c6d8: function(arg0) {
|
|
3379
|
+
const ret = arg0.length;
|
|
3380
|
+
return ret;
|
|
3381
|
+
},
|
|
3382
|
+
__wbg_limits_a80585efb442d985: function(arg0) {
|
|
3383
|
+
const ret = arg0.limits;
|
|
3384
|
+
return ret;
|
|
3385
|
+
},
|
|
3386
|
+
__wbg_limits_d4ef440224084d65: function(arg0) {
|
|
3387
|
+
const ret = arg0.limits;
|
|
3388
|
+
return ret;
|
|
3389
|
+
},
|
|
3390
|
+
__wbg_mapAsync_3546b4b874e14738: function(arg0, arg1, arg2, arg3) {
|
|
3391
|
+
const ret = arg0.mapAsync(arg1 >>> 0, arg2, arg3);
|
|
3392
|
+
return ret;
|
|
3393
|
+
},
|
|
3394
|
+
__wbg_maxBindGroups_2fac2855adae76bb: function(arg0) {
|
|
3395
|
+
const ret = arg0.maxBindGroups;
|
|
3396
|
+
return ret;
|
|
3397
|
+
},
|
|
3398
|
+
__wbg_maxBindingsPerBindGroup_7b8b526a1900701d: function(arg0) {
|
|
3399
|
+
const ret = arg0.maxBindingsPerBindGroup;
|
|
3400
|
+
return ret;
|
|
3401
|
+
},
|
|
3402
|
+
__wbg_maxBufferSize_475dcdac4810587e: function(arg0) {
|
|
3403
|
+
const ret = arg0.maxBufferSize;
|
|
3404
|
+
return ret;
|
|
3405
|
+
},
|
|
3406
|
+
__wbg_maxColorAttachmentBytesPerSample_5a04a2d5a9e122bb: function(arg0) {
|
|
3407
|
+
const ret = arg0.maxColorAttachmentBytesPerSample;
|
|
3408
|
+
return ret;
|
|
3409
|
+
},
|
|
3410
|
+
__wbg_maxColorAttachments_2a487bb283cf8f08: function(arg0) {
|
|
3411
|
+
const ret = arg0.maxColorAttachments;
|
|
3412
|
+
return ret;
|
|
3413
|
+
},
|
|
3414
|
+
__wbg_maxComputeInvocationsPerWorkgroup_72908780df74614a: function(arg0) {
|
|
3415
|
+
const ret = arg0.maxComputeInvocationsPerWorkgroup;
|
|
3416
|
+
return ret;
|
|
3417
|
+
},
|
|
3418
|
+
__wbg_maxComputeWorkgroupSizeX_92eeefd082aefd07: function(arg0) {
|
|
3419
|
+
const ret = arg0.maxComputeWorkgroupSizeX;
|
|
3420
|
+
return ret;
|
|
3421
|
+
},
|
|
3422
|
+
__wbg_maxComputeWorkgroupSizeY_54fecee60bfa33ae: function(arg0) {
|
|
3423
|
+
const ret = arg0.maxComputeWorkgroupSizeY;
|
|
3424
|
+
return ret;
|
|
3425
|
+
},
|
|
3426
|
+
__wbg_maxComputeWorkgroupSizeZ_868f559f4eebf95f: function(arg0) {
|
|
3427
|
+
const ret = arg0.maxComputeWorkgroupSizeZ;
|
|
3428
|
+
return ret;
|
|
3429
|
+
},
|
|
3430
|
+
__wbg_maxComputeWorkgroupStorageSize_b4fd07bd827bde34: function(arg0) {
|
|
3431
|
+
const ret = arg0.maxComputeWorkgroupStorageSize;
|
|
3432
|
+
return ret;
|
|
3433
|
+
},
|
|
3434
|
+
__wbg_maxComputeWorkgroupsPerDimension_2d88e3f8e1f984fc: function(arg0) {
|
|
3435
|
+
const ret = arg0.maxComputeWorkgroupsPerDimension;
|
|
3436
|
+
return ret;
|
|
3437
|
+
},
|
|
3438
|
+
__wbg_maxDynamicStorageBuffersPerPipelineLayout_d6f0075161a2ec8e: function(arg0) {
|
|
3439
|
+
const ret = arg0.maxDynamicStorageBuffersPerPipelineLayout;
|
|
3440
|
+
return ret;
|
|
3441
|
+
},
|
|
3442
|
+
__wbg_maxDynamicUniformBuffersPerPipelineLayout_4fc01fff17019d2b: function(arg0) {
|
|
3443
|
+
const ret = arg0.maxDynamicUniformBuffersPerPipelineLayout;
|
|
3444
|
+
return ret;
|
|
3445
|
+
},
|
|
3446
|
+
__wbg_maxSampledTexturesPerShaderStage_224452301226d09a: function(arg0) {
|
|
3447
|
+
const ret = arg0.maxSampledTexturesPerShaderStage;
|
|
3448
|
+
return ret;
|
|
3449
|
+
},
|
|
3450
|
+
__wbg_maxSamplersPerShaderStage_34936f99dde7ae66: function(arg0) {
|
|
3451
|
+
const ret = arg0.maxSamplersPerShaderStage;
|
|
3452
|
+
return ret;
|
|
3453
|
+
},
|
|
3454
|
+
__wbg_maxStorageBufferBindingSize_9582c7cfe68faac0: function(arg0) {
|
|
3455
|
+
const ret = arg0.maxStorageBufferBindingSize;
|
|
3456
|
+
return ret;
|
|
3457
|
+
},
|
|
3458
|
+
__wbg_maxStorageBuffersPerShaderStage_6403069e851040db: function(arg0) {
|
|
3459
|
+
const ret = arg0.maxStorageBuffersPerShaderStage;
|
|
3460
|
+
return ret;
|
|
3461
|
+
},
|
|
3462
|
+
__wbg_maxStorageTexturesPerShaderStage_e44d7d6ed85de663: function(arg0) {
|
|
3463
|
+
const ret = arg0.maxStorageTexturesPerShaderStage;
|
|
3464
|
+
return ret;
|
|
3465
|
+
},
|
|
3466
|
+
__wbg_maxTextureArrayLayers_0f2fe636cc0fa44f: function(arg0) {
|
|
3467
|
+
const ret = arg0.maxTextureArrayLayers;
|
|
3468
|
+
return ret;
|
|
3469
|
+
},
|
|
3470
|
+
__wbg_maxTextureDimension1D_501e1e21119c564f: function(arg0) {
|
|
3471
|
+
const ret = arg0.maxTextureDimension1D;
|
|
3472
|
+
return ret;
|
|
3473
|
+
},
|
|
3474
|
+
__wbg_maxTextureDimension2D_ac594a0008180ab6: function(arg0) {
|
|
3475
|
+
const ret = arg0.maxTextureDimension2D;
|
|
3476
|
+
return ret;
|
|
3477
|
+
},
|
|
3478
|
+
__wbg_maxTextureDimension3D_8e5638a46d5786b0: function(arg0) {
|
|
3479
|
+
const ret = arg0.maxTextureDimension3D;
|
|
3480
|
+
return ret;
|
|
3481
|
+
},
|
|
3482
|
+
__wbg_maxUniformBufferBindingSize_a4c4feca62b81571: function(arg0) {
|
|
3483
|
+
const ret = arg0.maxUniformBufferBindingSize;
|
|
3484
|
+
return ret;
|
|
3485
|
+
},
|
|
3486
|
+
__wbg_maxUniformBuffersPerShaderStage_505f14dd3f814492: function(arg0) {
|
|
3487
|
+
const ret = arg0.maxUniformBuffersPerShaderStage;
|
|
3488
|
+
return ret;
|
|
3489
|
+
},
|
|
3490
|
+
__wbg_maxVertexAttributes_c4f4881b2d20616b: function(arg0) {
|
|
3491
|
+
const ret = arg0.maxVertexAttributes;
|
|
3492
|
+
return ret;
|
|
3493
|
+
},
|
|
3494
|
+
__wbg_maxVertexBufferArrayStride_da0782b779fc1a38: function(arg0) {
|
|
3495
|
+
const ret = arg0.maxVertexBufferArrayStride;
|
|
3496
|
+
return ret;
|
|
3497
|
+
},
|
|
3498
|
+
__wbg_maxVertexBuffers_90e848bae7f01af3: function(arg0) {
|
|
3499
|
+
const ret = arg0.maxVertexBuffers;
|
|
3500
|
+
return ret;
|
|
3501
|
+
},
|
|
3502
|
+
__wbg_minStorageBufferOffsetAlignment_58fcc139ce14bbb9: function(arg0) {
|
|
3503
|
+
const ret = arg0.minStorageBufferOffsetAlignment;
|
|
3504
|
+
return ret;
|
|
3505
|
+
},
|
|
3506
|
+
__wbg_minUniformBufferOffsetAlignment_33ca7570ff80f825: function(arg0) {
|
|
3507
|
+
const ret = arg0.minUniformBufferOffsetAlignment;
|
|
3508
|
+
return ret;
|
|
3509
|
+
},
|
|
3510
|
+
__wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
|
|
3511
|
+
const ret = arg0.msCrypto;
|
|
3512
|
+
return ret;
|
|
3513
|
+
},
|
|
3514
|
+
__wbg_navigator_51379c10a84aeec9: function(arg0) {
|
|
3515
|
+
const ret = arg0.navigator;
|
|
3516
|
+
return ret;
|
|
3517
|
+
},
|
|
3518
|
+
__wbg_navigator_99621db14b3f1099: function(arg0) {
|
|
3519
|
+
const ret = arg0.navigator;
|
|
3520
|
+
return ret;
|
|
3521
|
+
},
|
|
3522
|
+
__wbg_new_0_3da9e97f24fc69be: function() {
|
|
3523
|
+
const ret = new Date();
|
|
3524
|
+
return ret;
|
|
3525
|
+
},
|
|
3526
|
+
__wbg_new_32b398fb48b6d94a: function() {
|
|
3527
|
+
const ret = new Array();
|
|
3528
|
+
return ret;
|
|
3529
|
+
},
|
|
3530
|
+
__wbg_new_cd45aabdf6073e84: function(arg0) {
|
|
3531
|
+
const ret = new Uint8Array(arg0);
|
|
3532
|
+
return ret;
|
|
3533
|
+
},
|
|
3534
|
+
__wbg_new_da52cf8fe3429cb2: function() {
|
|
3535
|
+
const ret = new Object();
|
|
3536
|
+
return ret;
|
|
3537
|
+
},
|
|
3538
|
+
__wbg_new_from_slice_77cdfb7977362f3c: function(arg0, arg1) {
|
|
3539
|
+
const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
|
|
3540
|
+
return ret;
|
|
3541
|
+
},
|
|
3542
|
+
__wbg_new_with_byte_offset_and_length_54c7724ee3ec7d82: function(arg0, arg1, arg2) {
|
|
3543
|
+
const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
|
|
3544
|
+
return ret;
|
|
3545
|
+
},
|
|
3546
|
+
__wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
|
|
3547
|
+
const ret = new Uint8Array(arg0 >>> 0);
|
|
3548
|
+
return ret;
|
|
3549
|
+
},
|
|
3550
|
+
__wbg_node_84ea875411254db1: function(arg0) {
|
|
3551
|
+
const ret = arg0.node;
|
|
3552
|
+
return ret;
|
|
3553
|
+
},
|
|
3554
|
+
__wbg_now_86c0d4ba3fa605b8: function() {
|
|
3555
|
+
const ret = Date.now();
|
|
3556
|
+
return ret;
|
|
3557
|
+
},
|
|
3558
|
+
__wbg_ok_acc5e3fb89668864: function(arg0) {
|
|
3559
|
+
const ret = arg0.ok;
|
|
3560
|
+
return ret;
|
|
3561
|
+
},
|
|
3562
|
+
__wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
|
|
3563
|
+
const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
|
|
3564
|
+
return ret;
|
|
3565
|
+
}, arguments); },
|
|
3566
|
+
__wbg_process_44c7a14e11e9f69e: function(arg0) {
|
|
3567
|
+
const ret = arg0.process;
|
|
3568
|
+
return ret;
|
|
3569
|
+
},
|
|
3570
|
+
__wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
|
|
3571
|
+
Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
|
|
3572
|
+
},
|
|
3573
|
+
__wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
|
|
3574
|
+
const ret = arg0.push(arg1);
|
|
3575
|
+
return ret;
|
|
3576
|
+
},
|
|
3577
|
+
__wbg_queueMicrotask_0ab5b2d2393e99b9: function(arg0) {
|
|
3578
|
+
const ret = arg0.queueMicrotask;
|
|
3579
|
+
return ret;
|
|
3580
|
+
},
|
|
3581
|
+
__wbg_queueMicrotask_6a09b7bc46549209: function(arg0) {
|
|
3582
|
+
queueMicrotask(arg0);
|
|
3583
|
+
},
|
|
3584
|
+
__wbg_queue_8cb065d04b06cb13: function(arg0) {
|
|
3585
|
+
const ret = arg0.queue;
|
|
3586
|
+
return ret;
|
|
3587
|
+
},
|
|
3588
|
+
__wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
|
|
3589
|
+
arg0.randomFillSync(arg1);
|
|
3590
|
+
}, arguments); },
|
|
3591
|
+
__wbg_requestAdapter_4814cb479d2dcf15: function(arg0, arg1) {
|
|
3592
|
+
const ret = arg0.requestAdapter(arg1);
|
|
3593
|
+
return ret;
|
|
3594
|
+
},
|
|
3595
|
+
__wbg_requestDevice_1b8f321791aa8b00: function(arg0, arg1) {
|
|
3596
|
+
const ret = arg0.requestDevice(arg1);
|
|
3597
|
+
return ret;
|
|
3598
|
+
},
|
|
3599
|
+
__wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
|
|
3600
|
+
const ret = module.require;
|
|
3601
|
+
return ret;
|
|
3602
|
+
}, arguments); },
|
|
3603
|
+
__wbg_resolve_2191a4dfe481c25b: function(arg0) {
|
|
3604
|
+
const ret = Promise.resolve(arg0);
|
|
3605
|
+
return ret;
|
|
3606
|
+
},
|
|
3607
|
+
__wbg_setBindGroup_9fdf11fd244aa68a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
|
|
3608
|
+
arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
|
|
3609
|
+
}, arguments); },
|
|
3610
|
+
__wbg_setBindGroup_a7e88440d0ecac88: function(arg0, arg1, arg2) {
|
|
3611
|
+
arg0.setBindGroup(arg1 >>> 0, arg2);
|
|
3612
|
+
},
|
|
3613
|
+
__wbg_setPipeline_092493bfd77760ee: function(arg0, arg1) {
|
|
3614
|
+
arg0.setPipeline(arg1);
|
|
3615
|
+
},
|
|
3616
|
+
__wbg_setVertexBuffer_1ed692dc2726f6c3: function(arg0, arg1, arg2, arg3, arg4) {
|
|
3617
|
+
arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
|
|
3618
|
+
},
|
|
3619
|
+
__wbg_set_61e45ae8061eca11: function(arg0, arg1, arg2) {
|
|
3620
|
+
arg0.set(arg1, arg2 >>> 0);
|
|
3621
|
+
},
|
|
3622
|
+
__wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
|
|
3623
|
+
const ret = Reflect.set(arg0, arg1, arg2);
|
|
3624
|
+
return ret;
|
|
3625
|
+
}, arguments); },
|
|
3626
|
+
__wbg_set_a_9b35e9a1b60244b3: function(arg0, arg1) {
|
|
3627
|
+
arg0.a = arg1;
|
|
3628
|
+
},
|
|
3629
|
+
__wbg_set_access_67a4b0ae1c0f32f5: function(arg0, arg1) {
|
|
3630
|
+
arg0.access = __wbindgen_enum_GpuStorageTextureAccess[arg1];
|
|
3631
|
+
},
|
|
3632
|
+
__wbg_set_address_mode_u_1a44abe112b27750: function(arg0, arg1) {
|
|
3633
|
+
arg0.addressModeU = __wbindgen_enum_GpuAddressMode[arg1];
|
|
3634
|
+
},
|
|
3635
|
+
__wbg_set_address_mode_v_764da2dbc77dbf3e: function(arg0, arg1) {
|
|
3636
|
+
arg0.addressModeV = __wbindgen_enum_GpuAddressMode[arg1];
|
|
3637
|
+
},
|
|
3638
|
+
__wbg_set_address_mode_w_7c5135c7d56f9b4c: function(arg0, arg1) {
|
|
3639
|
+
arg0.addressModeW = __wbindgen_enum_GpuAddressMode[arg1];
|
|
3640
|
+
},
|
|
3641
|
+
__wbg_set_alpha_52d96a0bda4f4afe: function(arg0, arg1) {
|
|
3642
|
+
arg0.alpha = arg1;
|
|
3643
|
+
},
|
|
3644
|
+
__wbg_set_alpha_mode_5c1f4c4115bbe318: function(arg0, arg1) {
|
|
3645
|
+
arg0.alphaMode = __wbindgen_enum_GpuCanvasAlphaMode[arg1];
|
|
3646
|
+
},
|
|
3647
|
+
__wbg_set_alpha_to_coverage_enabled_36cef063cffb5d84: function(arg0, arg1) {
|
|
3648
|
+
arg0.alphaToCoverageEnabled = arg1 !== 0;
|
|
3649
|
+
},
|
|
3650
|
+
__wbg_set_array_layer_count_c2e975f5b62596bb: function(arg0, arg1) {
|
|
3651
|
+
arg0.arrayLayerCount = arg1 >>> 0;
|
|
3652
|
+
},
|
|
3653
|
+
__wbg_set_array_stride_eb9d409a95d2c1b3: function(arg0, arg1) {
|
|
3654
|
+
arg0.arrayStride = arg1;
|
|
3655
|
+
},
|
|
3656
|
+
__wbg_set_aspect_a453970e75d8e849: function(arg0, arg1) {
|
|
3657
|
+
arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
|
|
3658
|
+
},
|
|
3659
|
+
__wbg_set_attributes_edcbef656678a257: function(arg0, arg1) {
|
|
3660
|
+
arg0.attributes = arg1;
|
|
3661
|
+
},
|
|
3662
|
+
__wbg_set_b_5708a52cef50b19f: function(arg0, arg1) {
|
|
3663
|
+
arg0.b = arg1;
|
|
3664
|
+
},
|
|
3665
|
+
__wbg_set_base_array_layer_b67db9750fbc7053: function(arg0, arg1) {
|
|
3666
|
+
arg0.baseArrayLayer = arg1 >>> 0;
|
|
3667
|
+
},
|
|
3668
|
+
__wbg_set_base_mip_level_35f2fc3293e96083: function(arg0, arg1) {
|
|
3669
|
+
arg0.baseMipLevel = arg1 >>> 0;
|
|
3670
|
+
},
|
|
3671
|
+
__wbg_set_beginning_of_pass_write_index_8e570668cd8cad5e: function(arg0, arg1) {
|
|
3672
|
+
arg0.beginningOfPassWriteIndex = arg1 >>> 0;
|
|
3673
|
+
},
|
|
3674
|
+
__wbg_set_bind_group_layouts_436bd62a9b35e1ab: function(arg0, arg1) {
|
|
3675
|
+
arg0.bindGroupLayouts = arg1;
|
|
3676
|
+
},
|
|
3677
|
+
__wbg_set_binding_b575483e08d5ba4a: function(arg0, arg1) {
|
|
3678
|
+
arg0.binding = arg1 >>> 0;
|
|
3679
|
+
},
|
|
3680
|
+
__wbg_set_binding_c9feebb53a130ebe: function(arg0, arg1) {
|
|
3681
|
+
arg0.binding = arg1 >>> 0;
|
|
3682
|
+
},
|
|
3683
|
+
__wbg_set_blend_765238525504b1db: function(arg0, arg1) {
|
|
3684
|
+
arg0.blend = arg1;
|
|
3685
|
+
},
|
|
3686
|
+
__wbg_set_buffer_468874ee2bc9df02: function(arg0, arg1) {
|
|
3687
|
+
arg0.buffer = arg1;
|
|
3688
|
+
},
|
|
3689
|
+
__wbg_set_buffer_6c45652fb024e808: function(arg0, arg1) {
|
|
3690
|
+
arg0.buffer = arg1;
|
|
3691
|
+
},
|
|
3692
|
+
__wbg_set_buffer_83041e80a2b2c1b9: function(arg0, arg1) {
|
|
3693
|
+
arg0.buffer = arg1;
|
|
3694
|
+
},
|
|
3695
|
+
__wbg_set_buffers_986b265eda61fae6: function(arg0, arg1) {
|
|
3696
|
+
arg0.buffers = arg1;
|
|
3697
|
+
},
|
|
3698
|
+
__wbg_set_bytes_per_row_c127092e4fe9be22: function(arg0, arg1) {
|
|
3699
|
+
arg0.bytesPerRow = arg1 >>> 0;
|
|
3700
|
+
},
|
|
3701
|
+
__wbg_set_bytes_per_row_fecf7d0d8d5038d0: function(arg0, arg1) {
|
|
3702
|
+
arg0.bytesPerRow = arg1 >>> 0;
|
|
3703
|
+
},
|
|
3704
|
+
__wbg_set_clear_value_764be6f32f502d0a: function(arg0, arg1) {
|
|
3705
|
+
arg0.clearValue = arg1;
|
|
3706
|
+
},
|
|
3707
|
+
__wbg_set_code_0a82fa86cf58ca3b: function(arg0, arg1, arg2) {
|
|
3708
|
+
arg0.code = getStringFromWasm0(arg1, arg2);
|
|
3709
|
+
},
|
|
3710
|
+
__wbg_set_color_attachments_fad73def169d9610: function(arg0, arg1) {
|
|
3711
|
+
arg0.colorAttachments = arg1;
|
|
3712
|
+
},
|
|
3713
|
+
__wbg_set_color_c25fb8769b4f010f: function(arg0, arg1) {
|
|
3714
|
+
arg0.color = arg1;
|
|
3715
|
+
},
|
|
3716
|
+
__wbg_set_compare_1e2214a402af6db3: function(arg0, arg1) {
|
|
3717
|
+
arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
3718
|
+
},
|
|
3719
|
+
__wbg_set_compare_e61cc62d8f7e2191: function(arg0, arg1) {
|
|
3720
|
+
arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
3721
|
+
},
|
|
3722
|
+
__wbg_set_count_f285d8c62f4de679: function(arg0, arg1) {
|
|
3723
|
+
arg0.count = arg1 >>> 0;
|
|
3724
|
+
},
|
|
3725
|
+
__wbg_set_cull_mode_e6ca97d167dede04: function(arg0, arg1) {
|
|
3726
|
+
arg0.cullMode = __wbindgen_enum_GpuCullMode[arg1];
|
|
3727
|
+
},
|
|
3728
|
+
__wbg_set_depth_bias_clamp_e8da3e9edc037b18: function(arg0, arg1) {
|
|
3729
|
+
arg0.depthBiasClamp = arg1;
|
|
3730
|
+
},
|
|
3731
|
+
__wbg_set_depth_bias_edf83e7d032bdd2a: function(arg0, arg1) {
|
|
3732
|
+
arg0.depthBias = arg1;
|
|
3733
|
+
},
|
|
3734
|
+
__wbg_set_depth_bias_slope_scale_1746553a2d960310: function(arg0, arg1) {
|
|
3735
|
+
arg0.depthBiasSlopeScale = arg1;
|
|
3736
|
+
},
|
|
3737
|
+
__wbg_set_depth_clear_value_f6f20e460b0c4012: function(arg0, arg1) {
|
|
3738
|
+
arg0.depthClearValue = arg1;
|
|
3739
|
+
},
|
|
3740
|
+
__wbg_set_depth_compare_f18e709a5dc4a0b0: function(arg0, arg1) {
|
|
3741
|
+
arg0.depthCompare = __wbindgen_enum_GpuCompareFunction[arg1];
|
|
3742
|
+
},
|
|
3743
|
+
__wbg_set_depth_fail_op_45f4179ddfc376cd: function(arg0, arg1) {
|
|
3744
|
+
arg0.depthFailOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
3745
|
+
},
|
|
3746
|
+
__wbg_set_depth_load_op_c3d15137e916dd5a: function(arg0, arg1) {
|
|
3747
|
+
arg0.depthLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
3748
|
+
},
|
|
3749
|
+
__wbg_set_depth_or_array_layers_17284e1eac0007a1: function(arg0, arg1) {
|
|
3750
|
+
arg0.depthOrArrayLayers = arg1 >>> 0;
|
|
3751
|
+
},
|
|
3752
|
+
__wbg_set_depth_read_only_9a8994459a0acf9e: function(arg0, arg1) {
|
|
3753
|
+
arg0.depthReadOnly = arg1 !== 0;
|
|
3754
|
+
},
|
|
3755
|
+
__wbg_set_depth_stencil_8716a627d44d796e: function(arg0, arg1) {
|
|
3756
|
+
arg0.depthStencil = arg1;
|
|
3757
|
+
},
|
|
3758
|
+
__wbg_set_depth_stencil_attachment_08fe1db9243adb49: function(arg0, arg1) {
|
|
3759
|
+
arg0.depthStencilAttachment = arg1;
|
|
3760
|
+
},
|
|
3761
|
+
__wbg_set_depth_store_op_881c8dbe0d67045d: function(arg0, arg1) {
|
|
3762
|
+
arg0.depthStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
3763
|
+
},
|
|
3764
|
+
__wbg_set_depth_write_enabled_9b608c3bf190f04a: function(arg0, arg1) {
|
|
3765
|
+
arg0.depthWriteEnabled = arg1 !== 0;
|
|
3766
|
+
},
|
|
3767
|
+
__wbg_set_device_bf67f52a587f9aab: function(arg0, arg1) {
|
|
3768
|
+
arg0.device = arg1;
|
|
3769
|
+
},
|
|
3770
|
+
__wbg_set_dimension_3144c827eb67b110: function(arg0, arg1) {
|
|
3771
|
+
arg0.dimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
3772
|
+
},
|
|
3773
|
+
__wbg_set_dimension_9054f7ab0acbfd31: function(arg0, arg1) {
|
|
3774
|
+
arg0.dimension = __wbindgen_enum_GpuTextureDimension[arg1];
|
|
3775
|
+
},
|
|
3776
|
+
__wbg_set_dst_factor_77c088c0ad43b684: function(arg0, arg1) {
|
|
3777
|
+
arg0.dstFactor = __wbindgen_enum_GpuBlendFactor[arg1];
|
|
3778
|
+
},
|
|
3779
|
+
__wbg_set_end_of_pass_write_index_568e7295b1b273a3: function(arg0, arg1) {
|
|
3780
|
+
arg0.endOfPassWriteIndex = arg1 >>> 0;
|
|
3781
|
+
},
|
|
3782
|
+
__wbg_set_entries_247b5e665db79583: function(arg0, arg1) {
|
|
3783
|
+
arg0.entries = arg1;
|
|
3784
|
+
},
|
|
3785
|
+
__wbg_set_entries_bfbb6a7f04b96709: function(arg0, arg1) {
|
|
3786
|
+
arg0.entries = arg1;
|
|
3787
|
+
},
|
|
3788
|
+
__wbg_set_entry_point_1d7ecf099e15fa2b: function(arg0, arg1, arg2) {
|
|
3789
|
+
arg0.entryPoint = getStringFromWasm0(arg1, arg2);
|
|
3790
|
+
},
|
|
3791
|
+
__wbg_set_entry_point_a698bc91b472d5a9: function(arg0, arg1, arg2) {
|
|
3792
|
+
arg0.entryPoint = getStringFromWasm0(arg1, arg2);
|
|
3793
|
+
},
|
|
3794
|
+
__wbg_set_external_texture_a0db2eb13c76e01c: function(arg0, arg1) {
|
|
3795
|
+
arg0.externalTexture = arg1;
|
|
3796
|
+
},
|
|
3797
|
+
__wbg_set_fail_op_a6890cff6b560a14: function(arg0, arg1) {
|
|
3798
|
+
arg0.failOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
3799
|
+
},
|
|
3800
|
+
__wbg_set_format_237b3e4047d1be9a: function(arg0, arg1) {
|
|
3801
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3802
|
+
},
|
|
3803
|
+
__wbg_set_format_53479155b45c92ea: function(arg0, arg1) {
|
|
3804
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3805
|
+
},
|
|
3806
|
+
__wbg_set_format_7c20bfc7e4802e1e: function(arg0, arg1) {
|
|
3807
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3808
|
+
},
|
|
3809
|
+
__wbg_set_format_84af8ed546a319fa: function(arg0, arg1) {
|
|
3810
|
+
arg0.format = __wbindgen_enum_GpuVertexFormat[arg1];
|
|
3811
|
+
},
|
|
3812
|
+
__wbg_set_format_9f32450123336995: function(arg0, arg1) {
|
|
3813
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3814
|
+
},
|
|
3815
|
+
__wbg_set_format_c9dcecebf9c1e619: function(arg0, arg1) {
|
|
3816
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3817
|
+
},
|
|
3818
|
+
__wbg_set_format_d9d3420c1a9d1c59: function(arg0, arg1) {
|
|
3819
|
+
arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
|
|
3820
|
+
},
|
|
3821
|
+
__wbg_set_fragment_2c6f6192456fed1c: function(arg0, arg1) {
|
|
3822
|
+
arg0.fragment = arg1;
|
|
3823
|
+
},
|
|
3824
|
+
__wbg_set_front_face_fd34f06ac9239d11: function(arg0, arg1) {
|
|
3825
|
+
arg0.frontFace = __wbindgen_enum_GpuFrontFace[arg1];
|
|
3826
|
+
},
|
|
3827
|
+
__wbg_set_g_7bb456722103c5e6: function(arg0, arg1) {
|
|
3828
|
+
arg0.g = arg1;
|
|
3829
|
+
},
|
|
3830
|
+
__wbg_set_has_dynamic_offset_0c8a607543be8069: function(arg0, arg1) {
|
|
3831
|
+
arg0.hasDynamicOffset = arg1 !== 0;
|
|
3832
|
+
},
|
|
3833
|
+
__wbg_set_height_7d9d8f892e6964c6: function(arg0, arg1) {
|
|
3834
|
+
arg0.height = arg1 >>> 0;
|
|
3835
|
+
},
|
|
3836
|
+
__wbg_set_height_96611e96eee67c44: function(arg0, arg1) {
|
|
3837
|
+
arg0.height = arg1 >>> 0;
|
|
3838
|
+
},
|
|
3839
|
+
__wbg_set_height_bbeef8f354041577: function(arg0, arg1) {
|
|
3840
|
+
arg0.height = arg1 >>> 0;
|
|
3841
|
+
},
|
|
3842
|
+
__wbg_set_label_01228663ea03b92f: function(arg0, arg1, arg2) {
|
|
3843
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3844
|
+
},
|
|
3845
|
+
__wbg_set_label_13a2dd9810399e8b: function(arg0, arg1, arg2) {
|
|
3846
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3847
|
+
},
|
|
3848
|
+
__wbg_set_label_22e57f4c5b38215f: function(arg0, arg1, arg2) {
|
|
3849
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3850
|
+
},
|
|
3851
|
+
__wbg_set_label_382417d222111912: function(arg0, arg1, arg2) {
|
|
3852
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3853
|
+
},
|
|
3854
|
+
__wbg_set_label_4d049edb707ba31c: function(arg0, arg1, arg2) {
|
|
3855
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3856
|
+
},
|
|
3857
|
+
__wbg_set_label_5724e5c6286e8a4e: function(arg0, arg1, arg2) {
|
|
3858
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
3859
|
+
},
|
|
3860
|
+
__wbg_set_label_8354c6463558484f: function(arg0, arg1, arg2) {
|
|
3861
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
2860
3862
|
},
|
|
2861
|
-
|
|
2862
|
-
|
|
2863
|
-
return ret;
|
|
3863
|
+
__wbg_set_label_acd66edf00f8e40f: function(arg0, arg1, arg2) {
|
|
3864
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
2864
3865
|
},
|
|
2865
|
-
|
|
2866
|
-
|
|
2867
|
-
return ret;
|
|
3866
|
+
__wbg_set_label_b3da7636c69f1a4c: function(arg0, arg1, arg2) {
|
|
3867
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
2868
3868
|
},
|
|
2869
|
-
|
|
2870
|
-
|
|
3869
|
+
__wbg_set_label_b7f797c13bc822c4: function(arg0, arg1, arg2) {
|
|
3870
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
2871
3871
|
},
|
|
2872
|
-
|
|
2873
|
-
|
|
2874
|
-
return ret;
|
|
2875
|
-
}, arguments); },
|
|
2876
|
-
__wbg_crypto_38df2bab126b63dc: function(arg0) {
|
|
2877
|
-
const ret = arg0.crypto;
|
|
2878
|
-
return ret;
|
|
3872
|
+
__wbg_set_label_e026aa2aea731594: function(arg0, arg1, arg2) {
|
|
3873
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
2879
3874
|
},
|
|
2880
|
-
|
|
2881
|
-
|
|
3875
|
+
__wbg_set_label_e6bc3b86ef6deeb8: function(arg0, arg1, arg2) {
|
|
3876
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
2882
3877
|
},
|
|
2883
|
-
|
|
2884
|
-
|
|
2885
|
-
return ret;
|
|
3878
|
+
__wbg_set_label_e7f76bba99d72971: function(arg0, arg1, arg2) {
|
|
3879
|
+
arg0.label = getStringFromWasm0(arg1, arg2);
|
|
2886
3880
|
},
|
|
2887
|
-
|
|
2888
|
-
|
|
2889
|
-
return ret;
|
|
3881
|
+
__wbg_set_layout_210c56f1b01e883b: function(arg0, arg1) {
|
|
3882
|
+
arg0.layout = arg1;
|
|
2890
3883
|
},
|
|
2891
|
-
|
|
2892
|
-
|
|
2893
|
-
return ret;
|
|
3884
|
+
__wbg_set_layout_44943c4c7d78f826: function(arg0, arg1) {
|
|
3885
|
+
arg0.layout = arg1;
|
|
2894
3886
|
},
|
|
2895
|
-
|
|
2896
|
-
|
|
2897
|
-
return ret;
|
|
3887
|
+
__wbg_set_load_op_103e6ce0a06327b3: function(arg0, arg1) {
|
|
3888
|
+
arg0.loadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
2898
3889
|
},
|
|
2899
|
-
|
|
2900
|
-
|
|
2901
|
-
return ret;
|
|
3890
|
+
__wbg_set_lod_max_clamp_3706b17de6a5a11a: function(arg0, arg1) {
|
|
3891
|
+
arg0.lodMaxClamp = arg1;
|
|
2902
3892
|
},
|
|
2903
|
-
|
|
2904
|
-
|
|
2905
|
-
return ret;
|
|
3893
|
+
__wbg_set_lod_min_clamp_1f4b28d77d0c87c4: function(arg0, arg1) {
|
|
3894
|
+
arg0.lodMinClamp = arg1;
|
|
2906
3895
|
},
|
|
2907
|
-
|
|
2908
|
-
arg0.
|
|
2909
|
-
}, arguments); },
|
|
2910
|
-
__wbg_length_1f0964f4a5e2c6d8: function(arg0) {
|
|
2911
|
-
const ret = arg0.length;
|
|
2912
|
-
return ret;
|
|
3896
|
+
__wbg_set_mag_filter_2c8c212ff297b151: function(arg0, arg1) {
|
|
3897
|
+
arg0.magFilter = __wbindgen_enum_GpuFilterMode[arg1];
|
|
2913
3898
|
},
|
|
2914
|
-
|
|
2915
|
-
|
|
2916
|
-
return ret;
|
|
3899
|
+
__wbg_set_mapped_at_creation_12773dff1bb6ea0f: function(arg0, arg1) {
|
|
3900
|
+
arg0.mappedAtCreation = arg1 !== 0;
|
|
2917
3901
|
},
|
|
2918
|
-
|
|
2919
|
-
|
|
2920
|
-
return ret;
|
|
3902
|
+
__wbg_set_mask_94311bacf22c96b1: function(arg0, arg1) {
|
|
3903
|
+
arg0.mask = arg1 >>> 0;
|
|
2921
3904
|
},
|
|
2922
|
-
|
|
2923
|
-
|
|
2924
|
-
return ret;
|
|
3905
|
+
__wbg_set_max_anisotropy_56bff110d0b4830f: function(arg0, arg1) {
|
|
3906
|
+
arg0.maxAnisotropy = arg1;
|
|
2925
3907
|
},
|
|
2926
|
-
|
|
2927
|
-
|
|
2928
|
-
return ret;
|
|
3908
|
+
__wbg_set_min_binding_size_164df827e02821e1: function(arg0, arg1) {
|
|
3909
|
+
arg0.minBindingSize = arg1;
|
|
2929
3910
|
},
|
|
2930
|
-
|
|
2931
|
-
|
|
2932
|
-
return ret;
|
|
3911
|
+
__wbg_set_min_filter_66d70efb70601bf9: function(arg0, arg1) {
|
|
3912
|
+
arg0.minFilter = __wbindgen_enum_GpuFilterMode[arg1];
|
|
2933
3913
|
},
|
|
2934
|
-
|
|
2935
|
-
|
|
2936
|
-
return ret;
|
|
2937
|
-
}, arguments); },
|
|
2938
|
-
__wbg_process_44c7a14e11e9f69e: function(arg0) {
|
|
2939
|
-
const ret = arg0.process;
|
|
2940
|
-
return ret;
|
|
3914
|
+
__wbg_set_mip_level_7f56c1c607dda5cf: function(arg0, arg1) {
|
|
3915
|
+
arg0.mipLevel = arg1 >>> 0;
|
|
2941
3916
|
},
|
|
2942
|
-
|
|
2943
|
-
|
|
3917
|
+
__wbg_set_mip_level_count_3402f5315a423b69: function(arg0, arg1) {
|
|
3918
|
+
arg0.mipLevelCount = arg1 >>> 0;
|
|
3919
|
+
},
|
|
3920
|
+
__wbg_set_mip_level_count_ed029120a0ee12b8: function(arg0, arg1) {
|
|
3921
|
+
arg0.mipLevelCount = arg1 >>> 0;
|
|
3922
|
+
},
|
|
3923
|
+
__wbg_set_mipmap_filter_1b3d153bd834ec26: function(arg0, arg1) {
|
|
3924
|
+
arg0.mipmapFilter = __wbindgen_enum_GpuMipmapFilterMode[arg1];
|
|
3925
|
+
},
|
|
3926
|
+
__wbg_set_module_119c125107e59165: function(arg0, arg1) {
|
|
3927
|
+
arg0.module = arg1;
|
|
3928
|
+
},
|
|
3929
|
+
__wbg_set_module_3336e0ce2672c07c: function(arg0, arg1) {
|
|
3930
|
+
arg0.module = arg1;
|
|
3931
|
+
},
|
|
3932
|
+
__wbg_set_multisample_1cdb4998c4f73341: function(arg0, arg1) {
|
|
3933
|
+
arg0.multisample = arg1;
|
|
3934
|
+
},
|
|
3935
|
+
__wbg_set_multisampled_e9d7bed0e68d1d6f: function(arg0, arg1) {
|
|
3936
|
+
arg0.multisampled = arg1 !== 0;
|
|
3937
|
+
},
|
|
3938
|
+
__wbg_set_offset_01c04218a4ccfa08: function(arg0, arg1) {
|
|
3939
|
+
arg0.offset = arg1;
|
|
3940
|
+
},
|
|
3941
|
+
__wbg_set_offset_5ea55c758ce6f103: function(arg0, arg1) {
|
|
3942
|
+
arg0.offset = arg1;
|
|
3943
|
+
},
|
|
3944
|
+
__wbg_set_offset_bd11f79890456c6f: function(arg0, arg1) {
|
|
3945
|
+
arg0.offset = arg1;
|
|
3946
|
+
},
|
|
3947
|
+
__wbg_set_offset_f07a73165707eb4c: function(arg0, arg1) {
|
|
3948
|
+
arg0.offset = arg1;
|
|
3949
|
+
},
|
|
3950
|
+
__wbg_set_operation_845ee9de4c1808be: function(arg0, arg1) {
|
|
3951
|
+
arg0.operation = __wbindgen_enum_GpuBlendOperation[arg1];
|
|
3952
|
+
},
|
|
3953
|
+
__wbg_set_origin_6be40076fb0623f4: function(arg0, arg1) {
|
|
3954
|
+
arg0.origin = arg1;
|
|
3955
|
+
},
|
|
3956
|
+
__wbg_set_pass_op_f4a566b4a6b819e0: function(arg0, arg1) {
|
|
3957
|
+
arg0.passOp = __wbindgen_enum_GpuStencilOperation[arg1];
|
|
3958
|
+
},
|
|
3959
|
+
__wbg_set_power_preference_0721cf46746c0c7d: function(arg0, arg1) {
|
|
3960
|
+
arg0.powerPreference = __wbindgen_enum_GpuPowerPreference[arg1];
|
|
3961
|
+
},
|
|
3962
|
+
__wbg_set_primitive_94234ea756a4c469: function(arg0, arg1) {
|
|
3963
|
+
arg0.primitive = arg1;
|
|
3964
|
+
},
|
|
3965
|
+
__wbg_set_query_set_667d2dcfcedd1ec2: function(arg0, arg1) {
|
|
3966
|
+
arg0.querySet = arg1;
|
|
3967
|
+
},
|
|
3968
|
+
__wbg_set_r_13b3eba61d4ba4d9: function(arg0, arg1) {
|
|
3969
|
+
arg0.r = arg1;
|
|
3970
|
+
},
|
|
3971
|
+
__wbg_set_required_features_5202fa8cd082e531: function(arg0, arg1) {
|
|
3972
|
+
arg0.requiredFeatures = arg1;
|
|
3973
|
+
},
|
|
3974
|
+
__wbg_set_resolve_target_8251ec563ce24501: function(arg0, arg1) {
|
|
3975
|
+
arg0.resolveTarget = arg1;
|
|
3976
|
+
},
|
|
3977
|
+
__wbg_set_resource_c73d0c2d815f7211: function(arg0, arg1) {
|
|
3978
|
+
arg0.resource = arg1;
|
|
3979
|
+
},
|
|
3980
|
+
__wbg_set_rows_per_image_00c8e938dae40dae: function(arg0, arg1) {
|
|
3981
|
+
arg0.rowsPerImage = arg1 >>> 0;
|
|
3982
|
+
},
|
|
3983
|
+
__wbg_set_rows_per_image_e6e2c0c4a7e4fa8d: function(arg0, arg1) {
|
|
3984
|
+
arg0.rowsPerImage = arg1 >>> 0;
|
|
3985
|
+
},
|
|
3986
|
+
__wbg_set_sample_count_05dcc9952f4fa7ac: function(arg0, arg1) {
|
|
3987
|
+
arg0.sampleCount = arg1 >>> 0;
|
|
3988
|
+
},
|
|
3989
|
+
__wbg_set_sample_type_93886b8f9794f85c: function(arg0, arg1) {
|
|
3990
|
+
arg0.sampleType = __wbindgen_enum_GpuTextureSampleType[arg1];
|
|
3991
|
+
},
|
|
3992
|
+
__wbg_set_sampler_02989e99b27a50db: function(arg0, arg1) {
|
|
3993
|
+
arg0.sampler = arg1;
|
|
3994
|
+
},
|
|
3995
|
+
__wbg_set_shader_location_33bfc2cc417fdde2: function(arg0, arg1) {
|
|
3996
|
+
arg0.shaderLocation = arg1 >>> 0;
|
|
3997
|
+
},
|
|
3998
|
+
__wbg_set_size_b3e6b2bf58d62082: function(arg0, arg1) {
|
|
3999
|
+
arg0.size = arg1;
|
|
4000
|
+
},
|
|
4001
|
+
__wbg_set_size_c2a556d5571231f5: function(arg0, arg1) {
|
|
4002
|
+
arg0.size = arg1;
|
|
4003
|
+
},
|
|
4004
|
+
__wbg_set_size_f7b29f6cb1669c4d: function(arg0, arg1) {
|
|
4005
|
+
arg0.size = arg1;
|
|
4006
|
+
},
|
|
4007
|
+
__wbg_set_src_factor_deefdfd4b6427b5e: function(arg0, arg1) {
|
|
4008
|
+
arg0.srcFactor = __wbindgen_enum_GpuBlendFactor[arg1];
|
|
4009
|
+
},
|
|
4010
|
+
__wbg_set_stencil_back_9971eece60c613eb: function(arg0, arg1) {
|
|
4011
|
+
arg0.stencilBack = arg1;
|
|
4012
|
+
},
|
|
4013
|
+
__wbg_set_stencil_clear_value_4b82f2d7e6d9f496: function(arg0, arg1) {
|
|
4014
|
+
arg0.stencilClearValue = arg1 >>> 0;
|
|
4015
|
+
},
|
|
4016
|
+
__wbg_set_stencil_front_c82ccf19db426a5b: function(arg0, arg1) {
|
|
4017
|
+
arg0.stencilFront = arg1;
|
|
4018
|
+
},
|
|
4019
|
+
__wbg_set_stencil_load_op_dbc3af9713146f24: function(arg0, arg1) {
|
|
4020
|
+
arg0.stencilLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
|
|
4021
|
+
},
|
|
4022
|
+
__wbg_set_stencil_read_mask_926bce469fa8eaf3: function(arg0, arg1) {
|
|
4023
|
+
arg0.stencilReadMask = arg1 >>> 0;
|
|
4024
|
+
},
|
|
4025
|
+
__wbg_set_stencil_read_only_88136eaf94225fec: function(arg0, arg1) {
|
|
4026
|
+
arg0.stencilReadOnly = arg1 !== 0;
|
|
4027
|
+
},
|
|
4028
|
+
__wbg_set_stencil_store_op_e10e50255bf42e8b: function(arg0, arg1) {
|
|
4029
|
+
arg0.stencilStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
4030
|
+
},
|
|
4031
|
+
__wbg_set_stencil_write_mask_3a7b75284ae036de: function(arg0, arg1) {
|
|
4032
|
+
arg0.stencilWriteMask = arg1 >>> 0;
|
|
4033
|
+
},
|
|
4034
|
+
__wbg_set_step_mode_2a36020da93d6f16: function(arg0, arg1) {
|
|
4035
|
+
arg0.stepMode = __wbindgen_enum_GpuVertexStepMode[arg1];
|
|
4036
|
+
},
|
|
4037
|
+
__wbg_set_storage_texture_50af47fec531be02: function(arg0, arg1) {
|
|
4038
|
+
arg0.storageTexture = arg1;
|
|
4039
|
+
},
|
|
4040
|
+
__wbg_set_store_op_23c150f1deb52749: function(arg0, arg1) {
|
|
4041
|
+
arg0.storeOp = __wbindgen_enum_GpuStoreOp[arg1];
|
|
4042
|
+
},
|
|
4043
|
+
__wbg_set_strip_index_format_bd4035f66052e74e: function(arg0, arg1) {
|
|
4044
|
+
arg0.stripIndexFormat = __wbindgen_enum_GpuIndexFormat[arg1];
|
|
4045
|
+
},
|
|
4046
|
+
__wbg_set_targets_d4d849b9c6abd35a: function(arg0, arg1) {
|
|
4047
|
+
arg0.targets = arg1;
|
|
4048
|
+
},
|
|
4049
|
+
__wbg_set_texture_884f2777c0fe1e91: function(arg0, arg1) {
|
|
4050
|
+
arg0.texture = arg1;
|
|
4051
|
+
},
|
|
4052
|
+
__wbg_set_texture_a1baf7da91d20351: function(arg0, arg1) {
|
|
4053
|
+
arg0.texture = arg1;
|
|
4054
|
+
},
|
|
4055
|
+
__wbg_set_timestamp_writes_fdf8168751575b7f: function(arg0, arg1) {
|
|
4056
|
+
arg0.timestampWrites = arg1;
|
|
4057
|
+
},
|
|
4058
|
+
__wbg_set_topology_0a07d5f484aff275: function(arg0, arg1) {
|
|
4059
|
+
arg0.topology = __wbindgen_enum_GpuPrimitiveTopology[arg1];
|
|
4060
|
+
},
|
|
4061
|
+
__wbg_set_type_109702a7ec65b49d: function(arg0, arg1) {
|
|
4062
|
+
arg0.type = __wbindgen_enum_GpuSamplerBindingType[arg1];
|
|
4063
|
+
},
|
|
4064
|
+
__wbg_set_type_55112c374bcc5a9d: function(arg0, arg1) {
|
|
4065
|
+
arg0.type = __wbindgen_enum_GpuBufferBindingType[arg1];
|
|
4066
|
+
},
|
|
4067
|
+
__wbg_set_unclipped_depth_b15740038a226817: function(arg0, arg1) {
|
|
4068
|
+
arg0.unclippedDepth = arg1 !== 0;
|
|
4069
|
+
},
|
|
4070
|
+
__wbg_set_usage_75d0e81d39ff5284: function(arg0, arg1) {
|
|
4071
|
+
arg0.usage = arg1 >>> 0;
|
|
4072
|
+
},
|
|
4073
|
+
__wbg_set_usage_ac04cadda4108c1a: function(arg0, arg1) {
|
|
4074
|
+
arg0.usage = arg1 >>> 0;
|
|
4075
|
+
},
|
|
4076
|
+
__wbg_set_usage_ad30cd3b0e0f4244: function(arg0, arg1) {
|
|
4077
|
+
arg0.usage = arg1 >>> 0;
|
|
4078
|
+
},
|
|
4079
|
+
__wbg_set_usage_cc34543608cf3335: function(arg0, arg1) {
|
|
4080
|
+
arg0.usage = arg1 >>> 0;
|
|
4081
|
+
},
|
|
4082
|
+
__wbg_set_vertex_13029c78ba2f0430: function(arg0, arg1) {
|
|
4083
|
+
arg0.vertex = arg1;
|
|
4084
|
+
},
|
|
4085
|
+
__wbg_set_view_6f2831c0da43be15: function(arg0, arg1) {
|
|
4086
|
+
arg0.view = arg1;
|
|
4087
|
+
},
|
|
4088
|
+
__wbg_set_view_b18c2cccd427261d: function(arg0, arg1) {
|
|
4089
|
+
arg0.view = arg1;
|
|
4090
|
+
},
|
|
4091
|
+
__wbg_set_view_dimension_50f3edb06107948f: function(arg0, arg1) {
|
|
4092
|
+
arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
4093
|
+
},
|
|
4094
|
+
__wbg_set_view_dimension_925bb358df1f2b9d: function(arg0, arg1) {
|
|
4095
|
+
arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
|
|
4096
|
+
},
|
|
4097
|
+
__wbg_set_view_formats_3d2a72ffb1f55a75: function(arg0, arg1) {
|
|
4098
|
+
arg0.viewFormats = arg1;
|
|
4099
|
+
},
|
|
4100
|
+
__wbg_set_view_formats_ae87e8e12aa858fc: function(arg0, arg1) {
|
|
4101
|
+
arg0.viewFormats = arg1;
|
|
4102
|
+
},
|
|
4103
|
+
__wbg_set_visibility_bdebc70a7c0f236d: function(arg0, arg1) {
|
|
4104
|
+
arg0.visibility = arg1 >>> 0;
|
|
4105
|
+
},
|
|
4106
|
+
__wbg_set_width_40592253da7b2113: function(arg0, arg1) {
|
|
4107
|
+
arg0.width = arg1 >>> 0;
|
|
4108
|
+
},
|
|
4109
|
+
__wbg_set_width_49ac9b7d914afc85: function(arg0, arg1) {
|
|
4110
|
+
arg0.width = arg1 >>> 0;
|
|
4111
|
+
},
|
|
4112
|
+
__wbg_set_width_8e30d010cd66830d: function(arg0, arg1) {
|
|
4113
|
+
arg0.width = arg1 >>> 0;
|
|
4114
|
+
},
|
|
4115
|
+
__wbg_set_write_mask_c03e8a45a9236e80: function(arg0, arg1) {
|
|
4116
|
+
arg0.writeMask = arg1 >>> 0;
|
|
4117
|
+
},
|
|
4118
|
+
__wbg_set_x_3c1cb8191b848172: function(arg0, arg1) {
|
|
4119
|
+
arg0.x = arg1 >>> 0;
|
|
4120
|
+
},
|
|
4121
|
+
__wbg_set_y_9024331910317eff: function(arg0, arg1) {
|
|
4122
|
+
arg0.y = arg1 >>> 0;
|
|
4123
|
+
},
|
|
4124
|
+
__wbg_set_z_b6182f4c230116a7: function(arg0, arg1) {
|
|
4125
|
+
arg0.z = arg1 >>> 0;
|
|
2944
4126
|
},
|
|
2945
|
-
__wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
|
|
2946
|
-
arg0.randomFillSync(arg1);
|
|
2947
|
-
}, arguments); },
|
|
2948
|
-
__wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
|
|
2949
|
-
const ret = module.require;
|
|
2950
|
-
return ret;
|
|
2951
|
-
}, arguments); },
|
|
2952
4127
|
__wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
|
|
2953
4128
|
const ret = typeof global === 'undefined' ? null : global;
|
|
2954
4129
|
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
@@ -2965,20 +4140,60 @@ function __wbg_get_imports() {
|
|
|
2965
4140
|
const ret = typeof window === 'undefined' ? null : window;
|
|
2966
4141
|
return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
|
|
2967
4142
|
},
|
|
4143
|
+
__wbg_status_c45b3b9b3033184a: function(arg0) {
|
|
4144
|
+
const ret = arg0.status;
|
|
4145
|
+
return ret;
|
|
4146
|
+
},
|
|
2968
4147
|
__wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
|
|
2969
4148
|
const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
|
|
2970
4149
|
return ret;
|
|
2971
4150
|
},
|
|
4151
|
+
__wbg_submit_fc5b9a1154201a58: function(arg0, arg1) {
|
|
4152
|
+
arg0.submit(arg1);
|
|
4153
|
+
},
|
|
4154
|
+
__wbg_then_16d107c451e9905d: function(arg0, arg1, arg2) {
|
|
4155
|
+
const ret = arg0.then(arg1, arg2);
|
|
4156
|
+
return ret;
|
|
4157
|
+
},
|
|
4158
|
+
__wbg_then_4a0b9283a66c4a8a: function(arg0, arg1, arg2) {
|
|
4159
|
+
const ret = arg0.then(arg1, arg2);
|
|
4160
|
+
return ret;
|
|
4161
|
+
},
|
|
4162
|
+
__wbg_then_6ec10ae38b3e92f7: function(arg0, arg1) {
|
|
4163
|
+
const ret = arg0.then(arg1);
|
|
4164
|
+
return ret;
|
|
4165
|
+
},
|
|
4166
|
+
__wbg_unmap_50b3be4aaf23fa39: function(arg0) {
|
|
4167
|
+
arg0.unmap();
|
|
4168
|
+
},
|
|
2972
4169
|
__wbg_versions_276b2795b1c6a219: function(arg0) {
|
|
2973
4170
|
const ret = arg0.versions;
|
|
2974
4171
|
return ret;
|
|
2975
4172
|
},
|
|
4173
|
+
__wbg_writeTexture_9d4c493be748d189: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
|
|
4174
|
+
arg0.writeTexture(arg1, arg2, arg3, arg4);
|
|
4175
|
+
}, arguments); },
|
|
2976
4176
|
__wbindgen_cast_0000000000000001: function(arg0, arg1) {
|
|
4177
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 1895, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
|
|
4178
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691);
|
|
4179
|
+
return ret;
|
|
4180
|
+
},
|
|
4181
|
+
__wbindgen_cast_0000000000000002: function(arg0, arg1) {
|
|
4182
|
+
// Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 3191, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
|
|
4183
|
+
const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5);
|
|
4184
|
+
return ret;
|
|
4185
|
+
},
|
|
4186
|
+
__wbindgen_cast_0000000000000003: function(arg0) {
|
|
4187
|
+
// Cast intrinsic for `F64 -> Externref`.
|
|
4188
|
+
const ret = arg0;
|
|
4189
|
+
return ret;
|
|
4190
|
+
},
|
|
4191
|
+
__wbindgen_cast_0000000000000004: function(arg0, arg1) {
|
|
2977
4192
|
// Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
|
|
2978
4193
|
const ret = getArrayU8FromWasm0(arg0, arg1);
|
|
2979
4194
|
return ret;
|
|
2980
4195
|
},
|
|
2981
|
-
|
|
4196
|
+
__wbindgen_cast_0000000000000005: function(arg0, arg1) {
|
|
2982
4197
|
// Cast intrinsic for `Ref(String) -> Externref`.
|
|
2983
4198
|
const ret = getStringFromWasm0(arg0, arg1);
|
|
2984
4199
|
return ret;
|
|
@@ -2999,6 +4214,91 @@ function __wbg_get_imports() {
|
|
|
2999
4214
|
};
|
|
3000
4215
|
}
|
|
3001
4216
|
|
|
4217
|
+
function wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691(arg0, arg1, arg2) {
|
|
4218
|
+
wasm.wasm_bindgen__convert__closures_____invoke__hd92f3b0a1cff0691(arg0, arg1, arg2);
|
|
4219
|
+
}
|
|
4220
|
+
|
|
4221
|
+
function wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2) {
|
|
4222
|
+
const ret = wasm.wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2);
|
|
4223
|
+
if (ret[1]) {
|
|
4224
|
+
throw takeFromExternrefTable0(ret[0]);
|
|
4225
|
+
}
|
|
4226
|
+
}
|
|
4227
|
+
|
|
4228
|
+
|
|
4229
|
+
const __wbindgen_enum_GpuAddressMode = ["clamp-to-edge", "repeat", "mirror-repeat"];
|
|
4230
|
+
|
|
4231
|
+
|
|
4232
|
+
const __wbindgen_enum_GpuBlendFactor = ["zero", "one", "src", "one-minus-src", "src-alpha", "one-minus-src-alpha", "dst", "one-minus-dst", "dst-alpha", "one-minus-dst-alpha", "src-alpha-saturated", "constant", "one-minus-constant", "src1", "one-minus-src1", "src1-alpha", "one-minus-src1-alpha"];
|
|
4233
|
+
|
|
4234
|
+
|
|
4235
|
+
const __wbindgen_enum_GpuBlendOperation = ["add", "subtract", "reverse-subtract", "min", "max"];
|
|
4236
|
+
|
|
4237
|
+
|
|
4238
|
+
const __wbindgen_enum_GpuBufferBindingType = ["uniform", "storage", "read-only-storage"];
|
|
4239
|
+
|
|
4240
|
+
|
|
4241
|
+
const __wbindgen_enum_GpuCanvasAlphaMode = ["opaque", "premultiplied"];
|
|
4242
|
+
|
|
4243
|
+
|
|
4244
|
+
const __wbindgen_enum_GpuCompareFunction = ["never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"];
|
|
4245
|
+
|
|
4246
|
+
|
|
4247
|
+
const __wbindgen_enum_GpuCullMode = ["none", "front", "back"];
|
|
4248
|
+
|
|
4249
|
+
|
|
4250
|
+
const __wbindgen_enum_GpuFilterMode = ["nearest", "linear"];
|
|
4251
|
+
|
|
4252
|
+
|
|
4253
|
+
const __wbindgen_enum_GpuFrontFace = ["ccw", "cw"];
|
|
4254
|
+
|
|
4255
|
+
|
|
4256
|
+
const __wbindgen_enum_GpuIndexFormat = ["uint16", "uint32"];
|
|
4257
|
+
|
|
4258
|
+
|
|
4259
|
+
const __wbindgen_enum_GpuLoadOp = ["load", "clear"];
|
|
4260
|
+
|
|
4261
|
+
|
|
4262
|
+
const __wbindgen_enum_GpuMipmapFilterMode = ["nearest", "linear"];
|
|
4263
|
+
|
|
4264
|
+
|
|
4265
|
+
const __wbindgen_enum_GpuPowerPreference = ["low-power", "high-performance"];
|
|
4266
|
+
|
|
4267
|
+
|
|
4268
|
+
const __wbindgen_enum_GpuPrimitiveTopology = ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"];
|
|
4269
|
+
|
|
4270
|
+
|
|
4271
|
+
const __wbindgen_enum_GpuSamplerBindingType = ["filtering", "non-filtering", "comparison"];
|
|
4272
|
+
|
|
4273
|
+
|
|
4274
|
+
const __wbindgen_enum_GpuStencilOperation = ["keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap"];
|
|
4275
|
+
|
|
4276
|
+
|
|
4277
|
+
const __wbindgen_enum_GpuStorageTextureAccess = ["write-only", "read-only", "read-write"];
|
|
4278
|
+
|
|
4279
|
+
|
|
4280
|
+
const __wbindgen_enum_GpuStoreOp = ["store", "discard"];
|
|
4281
|
+
|
|
4282
|
+
|
|
4283
|
+
const __wbindgen_enum_GpuTextureAspect = ["all", "stencil-only", "depth-only"];
|
|
4284
|
+
|
|
4285
|
+
|
|
4286
|
+
const __wbindgen_enum_GpuTextureDimension = ["1d", "2d", "3d"];
|
|
4287
|
+
|
|
4288
|
+
|
|
4289
|
+
const __wbindgen_enum_GpuTextureFormat = ["r8unorm", "r8snorm", "r8uint", "r8sint", "r16uint", "r16sint", "r16float", "rg8unorm", "rg8snorm", "rg8uint", "rg8sint", "r32uint", "r32sint", "r32float", "rg16uint", "rg16sint", "rg16float", "rgba8unorm", "rgba8unorm-srgb", "rgba8snorm", "rgba8uint", "rgba8sint", "bgra8unorm", "bgra8unorm-srgb", "rgb9e5ufloat", "rgb10a2uint", "rgb10a2unorm", "rg11b10ufloat", "rg32uint", "rg32sint", "rg32float", "rgba16uint", "rgba16sint", "rgba16float", "rgba32uint", "rgba32sint", "rgba32float", "stencil8", "depth16unorm", "depth24plus", "depth24plus-stencil8", "depth32float", "depth32float-stencil8", "bc1-rgba-unorm", "bc1-rgba-unorm-srgb", "bc2-rgba-unorm", "bc2-rgba-unorm-srgb", "bc3-rgba-unorm", "bc3-rgba-unorm-srgb", "bc4-r-unorm", "bc4-r-snorm", "bc5-rg-unorm", "bc5-rg-snorm", "bc6h-rgb-ufloat", "bc6h-rgb-float", "bc7-rgba-unorm", "bc7-rgba-unorm-srgb", "etc2-rgb8unorm", "etc2-rgb8unorm-srgb", "etc2-rgb8a1unorm", "etc2-rgb8a1unorm-srgb", "etc2-rgba8unorm", "etc2-rgba8unorm-srgb", "eac-r11unorm", "eac-r11snorm", "eac-rg11unorm", "eac-rg11snorm", "astc-4x4-unorm", "astc-4x4-unorm-srgb", "astc-5x4-unorm", "astc-5x4-unorm-srgb", "astc-5x5-unorm", "astc-5x5-unorm-srgb", "astc-6x5-unorm", "astc-6x5-unorm-srgb", "astc-6x6-unorm", "astc-6x6-unorm-srgb", "astc-8x5-unorm", "astc-8x5-unorm-srgb", "astc-8x6-unorm", "astc-8x6-unorm-srgb", "astc-8x8-unorm", "astc-8x8-unorm-srgb", "astc-10x5-unorm", "astc-10x5-unorm-srgb", "astc-10x6-unorm", "astc-10x6-unorm-srgb", "astc-10x8-unorm", "astc-10x8-unorm-srgb", "astc-10x10-unorm", "astc-10x10-unorm-srgb", "astc-12x10-unorm", "astc-12x10-unorm-srgb", "astc-12x12-unorm", "astc-12x12-unorm-srgb"];
|
|
4290
|
+
|
|
4291
|
+
|
|
4292
|
+
const __wbindgen_enum_GpuTextureSampleType = ["float", "unfilterable-float", "depth", "sint", "uint"];
|
|
4293
|
+
|
|
4294
|
+
|
|
4295
|
+
const __wbindgen_enum_GpuTextureViewDimension = ["1d", "2d", "2d-array", "cube", "cube-array", "3d"];
|
|
4296
|
+
|
|
4297
|
+
|
|
4298
|
+
const __wbindgen_enum_GpuVertexFormat = ["uint8", "uint8x2", "uint8x4", "sint8", "sint8x2", "sint8x4", "unorm8", "unorm8x2", "unorm8x4", "snorm8", "snorm8x2", "snorm8x4", "uint16", "uint16x2", "uint16x4", "sint16", "sint16x2", "sint16x4", "unorm16", "unorm16x2", "unorm16x4", "snorm16", "snorm16x2", "snorm16x4", "float16", "float16x2", "float16x4", "float32", "float32x2", "float32x3", "float32x4", "uint32", "uint32x2", "uint32x3", "uint32x4", "sint32", "sint32x2", "sint32x3", "sint32x4", "unorm10-10-10-2", "unorm8x4-bgra"];
|
|
4299
|
+
|
|
4300
|
+
|
|
4301
|
+
const __wbindgen_enum_GpuVertexStepMode = ["vertex", "instance"];
|
|
3002
4302
|
const CredentialVaultFinalization = (typeof FinalizationRegistry === 'undefined')
|
|
3003
4303
|
? { register: () => {}, unregister: () => {} }
|
|
3004
4304
|
: new FinalizationRegistry(ptr => wasm.__wbg_credentialvault_free(ptr, 1));
|
|
@@ -3018,15 +4318,105 @@ function addToExternrefTable0(obj) {
|
|
|
3018
4318
|
return idx;
|
|
3019
4319
|
}
|
|
3020
4320
|
|
|
4321
|
+
const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
|
|
4322
|
+
? { register: () => {}, unregister: () => {} }
|
|
4323
|
+
: new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
|
|
4324
|
+
|
|
4325
|
+
function debugString(val) {
|
|
4326
|
+
// primitive types
|
|
4327
|
+
const type = typeof val;
|
|
4328
|
+
if (type == 'number' || type == 'boolean' || val == null) {
|
|
4329
|
+
return `${val}`;
|
|
4330
|
+
}
|
|
4331
|
+
if (type == 'string') {
|
|
4332
|
+
return `"${val}"`;
|
|
4333
|
+
}
|
|
4334
|
+
if (type == 'symbol') {
|
|
4335
|
+
const description = val.description;
|
|
4336
|
+
if (description == null) {
|
|
4337
|
+
return 'Symbol';
|
|
4338
|
+
} else {
|
|
4339
|
+
return `Symbol(${description})`;
|
|
4340
|
+
}
|
|
4341
|
+
}
|
|
4342
|
+
if (type == 'function') {
|
|
4343
|
+
const name = val.name;
|
|
4344
|
+
if (typeof name == 'string' && name.length > 0) {
|
|
4345
|
+
return `Function(${name})`;
|
|
4346
|
+
} else {
|
|
4347
|
+
return 'Function';
|
|
4348
|
+
}
|
|
4349
|
+
}
|
|
4350
|
+
// objects
|
|
4351
|
+
if (Array.isArray(val)) {
|
|
4352
|
+
const length = val.length;
|
|
4353
|
+
let debug = '[';
|
|
4354
|
+
if (length > 0) {
|
|
4355
|
+
debug += debugString(val[0]);
|
|
4356
|
+
}
|
|
4357
|
+
for(let i = 1; i < length; i++) {
|
|
4358
|
+
debug += ', ' + debugString(val[i]);
|
|
4359
|
+
}
|
|
4360
|
+
debug += ']';
|
|
4361
|
+
return debug;
|
|
4362
|
+
}
|
|
4363
|
+
// Test for built-in
|
|
4364
|
+
const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
|
|
4365
|
+
let className;
|
|
4366
|
+
if (builtInMatches && builtInMatches.length > 1) {
|
|
4367
|
+
className = builtInMatches[1];
|
|
4368
|
+
} else {
|
|
4369
|
+
// Failed to match the standard '[object ClassName]'
|
|
4370
|
+
return toString.call(val);
|
|
4371
|
+
}
|
|
4372
|
+
if (className == 'Object') {
|
|
4373
|
+
// we're a user defined class or Object
|
|
4374
|
+
// JSON.stringify avoids problems with cycles, and is generally much
|
|
4375
|
+
// easier than looping through ownProperties of `val`.
|
|
4376
|
+
try {
|
|
4377
|
+
return 'Object(' + JSON.stringify(val) + ')';
|
|
4378
|
+
} catch (_) {
|
|
4379
|
+
return 'Object';
|
|
4380
|
+
}
|
|
4381
|
+
}
|
|
4382
|
+
// errors
|
|
4383
|
+
if (val instanceof Error) {
|
|
4384
|
+
return `${val.name}: ${val.message}\n${val.stack}`;
|
|
4385
|
+
}
|
|
4386
|
+
// TODO we could test for more things here, like `Set`s and `Map`s.
|
|
4387
|
+
return className;
|
|
4388
|
+
}
|
|
4389
|
+
|
|
4390
|
+
function getArrayU32FromWasm0(ptr, len) {
|
|
4391
|
+
ptr = ptr >>> 0;
|
|
4392
|
+
return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
|
|
4393
|
+
}
|
|
4394
|
+
|
|
3021
4395
|
function getArrayU8FromWasm0(ptr, len) {
|
|
3022
4396
|
ptr = ptr >>> 0;
|
|
3023
4397
|
return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
|
|
3024
4398
|
}
|
|
3025
4399
|
|
|
4400
|
+
let cachedDataViewMemory0 = null;
|
|
4401
|
+
function getDataViewMemory0() {
|
|
4402
|
+
if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
|
|
4403
|
+
cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
|
|
4404
|
+
}
|
|
4405
|
+
return cachedDataViewMemory0;
|
|
4406
|
+
}
|
|
4407
|
+
|
|
3026
4408
|
function getStringFromWasm0(ptr, len) {
|
|
3027
4409
|
return decodeText(ptr >>> 0, len);
|
|
3028
4410
|
}
|
|
3029
4411
|
|
|
4412
|
+
let cachedUint32ArrayMemory0 = null;
|
|
4413
|
+
function getUint32ArrayMemory0() {
|
|
4414
|
+
if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
|
|
4415
|
+
cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
|
|
4416
|
+
}
|
|
4417
|
+
return cachedUint32ArrayMemory0;
|
|
4418
|
+
}
|
|
4419
|
+
|
|
3030
4420
|
let cachedUint8ArrayMemory0 = null;
|
|
3031
4421
|
function getUint8ArrayMemory0() {
|
|
3032
4422
|
if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
|
|
@@ -3048,6 +4438,34 @@ function isLikeNone(x) {
|
|
|
3048
4438
|
return x === undefined || x === null;
|
|
3049
4439
|
}
|
|
3050
4440
|
|
|
4441
|
+
function makeMutClosure(arg0, arg1, f) {
|
|
4442
|
+
const state = { a: arg0, b: arg1, cnt: 1 };
|
|
4443
|
+
const real = (...args) => {
|
|
4444
|
+
|
|
4445
|
+
// First up with a closure we increment the internal reference
|
|
4446
|
+
// count. This ensures that the Rust closure environment won't
|
|
4447
|
+
// be deallocated while we're invoking it.
|
|
4448
|
+
state.cnt++;
|
|
4449
|
+
const a = state.a;
|
|
4450
|
+
state.a = 0;
|
|
4451
|
+
try {
|
|
4452
|
+
return f(a, state.b, ...args);
|
|
4453
|
+
} finally {
|
|
4454
|
+
state.a = a;
|
|
4455
|
+
real._wbg_cb_unref();
|
|
4456
|
+
}
|
|
4457
|
+
};
|
|
4458
|
+
real._wbg_cb_unref = () => {
|
|
4459
|
+
if (--state.cnt === 0) {
|
|
4460
|
+
wasm.__wbindgen_destroy_closure(state.a, state.b);
|
|
4461
|
+
state.a = 0;
|
|
4462
|
+
CLOSURE_DTORS.unregister(state);
|
|
4463
|
+
}
|
|
4464
|
+
};
|
|
4465
|
+
CLOSURE_DTORS.register(real, state, state);
|
|
4466
|
+
return real;
|
|
4467
|
+
}
|
|
4468
|
+
|
|
3051
4469
|
function passStringToWasm0(arg, malloc, realloc) {
|
|
3052
4470
|
if (realloc === undefined) {
|
|
3053
4471
|
const buf = cachedTextEncoder.encode(arg);
|
|
@@ -3125,6 +4543,8 @@ function __wbg_finalize_init(instance, module) {
|
|
|
3125
4543
|
wasmInstance = instance;
|
|
3126
4544
|
wasm = instance.exports;
|
|
3127
4545
|
wasmModule = module;
|
|
4546
|
+
cachedDataViewMemory0 = null;
|
|
4547
|
+
cachedUint32ArrayMemory0 = null;
|
|
3128
4548
|
cachedUint8ArrayMemory0 = null;
|
|
3129
4549
|
wasm.__wbindgen_start();
|
|
3130
4550
|
return wasm;
|