@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.
@@ -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 deferred5_0;
616
- let deferred5_1;
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
- const ret = wasm.kernel_dispatchMount(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
625
- var ptr4 = ret[0];
626
- var len4 = ret[1];
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
- ptr4 = 0; len4 = 0;
631
+ ptr5 = 0; len5 = 0;
629
632
  throw takeFromExternrefTable0(ret[2]);
630
633
  }
631
- deferred5_0 = ptr4;
632
- deferred5_1 = len4;
633
- return getStringFromWasm0(ptr4, len4);
634
+ deferred6_0 = ptr5;
635
+ deferred6_1 = len5;
636
+ return getStringFromWasm0(ptr5, len5);
634
637
  } finally {
635
- wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
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} site_json
2754
- * @param {string} key
2755
- * @param {string} op
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 substrateCompletionEvent(site_json, key, op, args_json, outcome_json) {
2761
- let deferred7_0;
2762
- let deferred7_1;
2871
+ export function skinApplyAffine(matrix_json, x, y) {
2872
+ let deferred3_0;
2873
+ let deferred3_1;
2763
2874
  try {
2764
- const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2875
+ const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2765
2876
  const len0 = WASM_VECTOR_LEN;
2766
- const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
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 ptr2 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2769
- const len2 = WASM_VECTOR_LEN;
2770
- const ptr3 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
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
- ptr6 = 0; len6 = 0;
2909
+ ptr3 = 0; len3 = 0;
2779
2910
  throw takeFromExternrefTable0(ret[2]);
2780
2911
  }
2781
- deferred7_0 = ptr6;
2782
- deferred7_1 = len6;
2783
- return getStringFromWasm0(ptr6, len6);
2912
+ deferred4_0 = ptr3;
2913
+ deferred4_1 = len3;
2914
+ return getStringFromWasm0(ptr3, len3);
2784
2915
  } finally {
2785
- wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
2916
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2786
2917
  }
2787
2918
  }
2788
2919
 
2789
2920
  /**
2790
- * Whether the Chrome match pattern `pattern` matches `url`.
2791
- * @param {string} pattern
2792
- * @param {string} url
2793
- * @returns {boolean}
2921
+ * @param {string} matrix_json
2922
+ * @param {number} bone
2923
+ * @returns {string}
2794
2924
  */
2795
- export function tabUrlMatches(pattern, url) {
2796
- const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2797
- const len0 = WASM_VECTOR_LEN;
2798
- const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2799
- const len1 = WASM_VECTOR_LEN;
2800
- const ret = wasm.tabUrlMatches(ptr0, len0, ptr1, len1);
2801
- return ret !== 0;
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
- * Effects run in order against a row (`TraceEffectsWire` as JSON): a trace per effect, the events raised, the writes made.
2806
- * @param {string} context_json
2807
- * @param {string} effects_json
2947
+ * @param {string} src_json
2948
+ * @param {string} dst_json
2808
2949
  * @returns {string}
2809
2950
  */
2810
- export function traceEffects(context_json, effects_json) {
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(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2955
+ const ptr0 = passStringToWasm0(src_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2815
2956
  const len0 = WASM_VECTOR_LEN;
2816
- const ptr1 = passStringToWasm0(effects_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2957
+ const ptr1 = passStringToWasm0(dst_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2817
2958
  const len1 = WASM_VECTOR_LEN;
2818
- const ret = wasm.traceEffects(ptr0, len0, ptr1, len1);
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
- * The kernel's verdict on language packs (`[{ package, definition }]` as JSON): throws the refusal that names each pack, section and word.
2835
- * @param {string} packs_json
2975
+ * @param {string} points_json
2976
+ * @returns {string}
2836
2977
  */
2837
- export function validatePacks(packs_json) {
2838
- const ptr0 = passStringToWasm0(packs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2839
- const len0 = WASM_VECTOR_LEN;
2840
- const ret = wasm.validatePacks(ptr0, len0);
2841
- if (ret[1]) {
2842
- throw takeFromExternrefTable0(ret[0]);
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
- function __wbg_get_imports() {
2846
- const import0 = {
2847
- __proto__: null,
2848
- __wbg_Error_92b29b0548f8b746: function(arg0, arg1) {
2849
- const ret = Error(getStringFromWasm0(arg0, arg1));
2850
- return ret;
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
- __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
2857
- const val = arg0;
2858
- const ret = typeof(val) === 'object' && val !== null;
2859
- return ret;
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
- __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
2862
- const ret = typeof(arg0) === 'string';
2863
- return ret;
3863
+ __wbg_set_label_acd66edf00f8e40f: function(arg0, arg1, arg2) {
3864
+ arg0.label = getStringFromWasm0(arg1, arg2);
2864
3865
  },
2865
- __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
2866
- const ret = arg0 === undefined;
2867
- return ret;
3866
+ __wbg_set_label_b3da7636c69f1a4c: function(arg0, arg1, arg2) {
3867
+ arg0.label = getStringFromWasm0(arg1, arg2);
2868
3868
  },
2869
- __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
2870
- throw new Error(getStringFromWasm0(arg0, arg1));
3869
+ __wbg_set_label_b7f797c13bc822c4: function(arg0, arg1, arg2) {
3870
+ arg0.label = getStringFromWasm0(arg1, arg2);
2871
3871
  },
2872
- __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
2873
- const ret = arg0.call(arg1, arg2);
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
- __wbg_error_96e899f14d8344a2: function(arg0, arg1) {
2881
- console.error(getStringFromWasm0(arg0, arg1));
3875
+ __wbg_set_label_e6bc3b86ef6deeb8: function(arg0, arg1, arg2) {
3876
+ arg0.label = getStringFromWasm0(arg1, arg2);
2882
3877
  },
2883
- __wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
2884
- const ret = arg0.getDate();
2885
- return ret;
3878
+ __wbg_set_label_e7f76bba99d72971: function(arg0, arg1, arg2) {
3879
+ arg0.label = getStringFromWasm0(arg1, arg2);
2886
3880
  },
2887
- __wbg_getDay_aa318cce5da74c49: function(arg0) {
2888
- const ret = arg0.getDay();
2889
- return ret;
3881
+ __wbg_set_layout_210c56f1b01e883b: function(arg0, arg1) {
3882
+ arg0.layout = arg1;
2890
3883
  },
2891
- __wbg_getFullYear_6af8b229792ae254: function(arg0) {
2892
- const ret = arg0.getFullYear();
2893
- return ret;
3884
+ __wbg_set_layout_44943c4c7d78f826: function(arg0, arg1) {
3885
+ arg0.layout = arg1;
2894
3886
  },
2895
- __wbg_getHours_9f6561095682ce51: function(arg0) {
2896
- const ret = arg0.getHours();
2897
- return ret;
3887
+ __wbg_set_load_op_103e6ce0a06327b3: function(arg0, arg1) {
3888
+ arg0.loadOp = __wbindgen_enum_GpuLoadOp[arg1];
2898
3889
  },
2899
- __wbg_getMinutes_b0d5cd90bf9b8f22: function(arg0) {
2900
- const ret = arg0.getMinutes();
2901
- return ret;
3890
+ __wbg_set_lod_max_clamp_3706b17de6a5a11a: function(arg0, arg1) {
3891
+ arg0.lodMaxClamp = arg1;
2902
3892
  },
2903
- __wbg_getMonth_fffe29d654d5eb69: function(arg0) {
2904
- const ret = arg0.getMonth();
2905
- return ret;
3893
+ __wbg_set_lod_min_clamp_1f4b28d77d0c87c4: function(arg0, arg1) {
3894
+ arg0.lodMinClamp = arg1;
2906
3895
  },
2907
- __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
2908
- arg0.getRandomValues(arg1);
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
- __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
2915
- const ret = arg0.msCrypto;
2916
- return ret;
3899
+ __wbg_set_mapped_at_creation_12773dff1bb6ea0f: function(arg0, arg1) {
3900
+ arg0.mappedAtCreation = arg1 !== 0;
2917
3901
  },
2918
- __wbg_new_0_3da9e97f24fc69be: function() {
2919
- const ret = new Date();
2920
- return ret;
3902
+ __wbg_set_mask_94311bacf22c96b1: function(arg0, arg1) {
3903
+ arg0.mask = arg1 >>> 0;
2921
3904
  },
2922
- __wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
2923
- const ret = new Uint8Array(arg0 >>> 0);
2924
- return ret;
3905
+ __wbg_set_max_anisotropy_56bff110d0b4830f: function(arg0, arg1) {
3906
+ arg0.maxAnisotropy = arg1;
2925
3907
  },
2926
- __wbg_node_84ea875411254db1: function(arg0) {
2927
- const ret = arg0.node;
2928
- return ret;
3908
+ __wbg_set_min_binding_size_164df827e02821e1: function(arg0, arg1) {
3909
+ arg0.minBindingSize = arg1;
2929
3910
  },
2930
- __wbg_now_86c0d4ba3fa605b8: function() {
2931
- const ret = Date.now();
2932
- return ret;
3911
+ __wbg_set_min_filter_66d70efb70601bf9: function(arg0, arg1) {
3912
+ arg0.minFilter = __wbindgen_enum_GpuFilterMode[arg1];
2933
3913
  },
2934
- __wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
2935
- const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
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
- __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
2943
- Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
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
- __wbindgen_cast_0000000000000002: function(arg0, arg1) {
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;