@almadar/kernel 19.0.0 → 19.1.0

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.
@@ -1,5 +1,203 @@
1
1
  /* @ts-self-types="./orbital_wasm.d.ts" */
2
2
 
3
+ export class Canvas3D {
4
+ static __wrap(ptr) {
5
+ const obj = Object.create(Canvas3D.prototype);
6
+ obj.__wbg_ptr = ptr;
7
+ Canvas3DFinalization.register(obj, obj.__wbg_ptr, obj);
8
+ return obj;
9
+ }
10
+ __destroy_into_raw() {
11
+ const ptr = this.__wbg_ptr;
12
+ this.__wbg_ptr = 0;
13
+ Canvas3DFinalization.unregister(this);
14
+ return ptr;
15
+ }
16
+ free() {
17
+ const ptr = this.__destroy_into_raw();
18
+ wasm.__wbg_canvas3d_free(ptr, 0);
19
+ }
20
+ /**
21
+ * The camera as the user moved it, as JSON (`eye`, `target`, `up`, `projection`, `near`, `far`).
22
+ * @returns {string}
23
+ */
24
+ camera() {
25
+ let deferred1_0;
26
+ let deferred1_1;
27
+ try {
28
+ const ret = wasm.canvas3d_camera(this.__wbg_ptr);
29
+ deferred1_0 = ret[0];
30
+ deferred1_1 = ret[1];
31
+ return getStringFromWasm0(ret[0], ret[1]);
32
+ } finally {
33
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
34
+ }
35
+ }
36
+ /**
37
+ * Opens (or joins) the shared device and makes a surface on `canvas`.
38
+ * @param {HTMLCanvasElement} canvas
39
+ * @returns {Promise<Canvas3D>}
40
+ */
41
+ static create(canvas) {
42
+ const ret = wasm.canvas3d_create(canvas);
43
+ return ret;
44
+ }
45
+ /**
46
+ * Advances the canvas clock to `now_ms` (`performance.now()`) with the page clock `epoch_ms`
47
+ * (`performance.timeOrigin + now`); true when the frame changed.
48
+ * @param {number} now_ms
49
+ * @param {number} epoch_ms
50
+ * @returns {boolean}
51
+ */
52
+ frame(now_ms, epoch_ms) {
53
+ const ret = wasm.canvas3d_frame(this.__wbg_ptr, now_ms, epoch_ms);
54
+ if (ret[2]) {
55
+ throw takeFromExternrefTable0(ret[1]);
56
+ }
57
+ return ret[0] !== 0;
58
+ }
59
+ /**
60
+ * @param {string} target_json
61
+ * @returns {boolean}
62
+ */
63
+ lookAt(target_json) {
64
+ const ptr0 = passStringToWasm0(target_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
65
+ const len0 = WASM_VECTOR_LEN;
66
+ const ret = wasm.canvas3d_lookAt(this.__wbg_ptr, ptr0, len0);
67
+ if (ret[2]) {
68
+ throw takeFromExternrefTable0(ret[1]);
69
+ }
70
+ return ret[0] !== 0;
71
+ }
72
+ /**
73
+ * @param {number} id
74
+ * @param {number} x
75
+ * @param {number} y
76
+ * @param {number} button_code
77
+ * @param {boolean} touch
78
+ */
79
+ pointerDown(id, x, y, button_code, touch) {
80
+ wasm.canvas3d_pointerDown(this.__wbg_ptr, id, x, y, button_code, touch);
81
+ }
82
+ pointerLeave() {
83
+ wasm.canvas3d_pointerLeave(this.__wbg_ptr);
84
+ }
85
+ /**
86
+ * @param {number} id
87
+ * @param {number} x
88
+ * @param {number} y
89
+ * @returns {boolean}
90
+ */
91
+ pointerMove(id, x, y) {
92
+ const ret = wasm.canvas3d_pointerMove(this.__wbg_ptr, id, x, y);
93
+ if (ret[2]) {
94
+ throw takeFromExternrefTable0(ret[1]);
95
+ }
96
+ return ret[0] !== 0;
97
+ }
98
+ /**
99
+ * What the release did, as JSON: `{"unit":{"id","x","z"}}`, `{"tile":{"x","z"}}`, `{"select":{"id"}}`,
100
+ * `{"move":{"id","x","y"}}`, `{"shape":<the pattern's click payload>}`, or `null`.
101
+ * @param {number} id
102
+ * @param {number} x
103
+ * @param {number} y
104
+ * @param {boolean} unit_events
105
+ * @param {boolean} tile_events
106
+ * @returns {string}
107
+ */
108
+ pointerUp(id, x, y, unit_events, tile_events) {
109
+ let deferred2_0;
110
+ let deferred2_1;
111
+ try {
112
+ const ret = wasm.canvas3d_pointerUp(this.__wbg_ptr, id, x, y, unit_events, tile_events);
113
+ var ptr1 = ret[0];
114
+ var len1 = ret[1];
115
+ if (ret[3]) {
116
+ ptr1 = 0; len1 = 0;
117
+ throw takeFromExternrefTable0(ret[2]);
118
+ }
119
+ deferred2_0 = ptr1;
120
+ deferred2_1 = len1;
121
+ return getStringFromWasm0(ptr1, len1);
122
+ } finally {
123
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
124
+ }
125
+ }
126
+ render() {
127
+ const ret = wasm.canvas3d_render(this.__wbg_ptr);
128
+ if (ret[1]) {
129
+ throw takeFromExternrefTable0(ret[0]);
130
+ }
131
+ }
132
+ /**
133
+ * @returns {boolean}
134
+ */
135
+ resetCamera() {
136
+ const ret = wasm.canvas3d_resetCamera(this.__wbg_ptr);
137
+ return ret !== 0;
138
+ }
139
+ /**
140
+ * @param {number} css_width
141
+ * @param {number} css_height
142
+ * @param {number} pixel_ratio
143
+ */
144
+ resize(css_width, css_height, pixel_ratio) {
145
+ wasm.canvas3d_resize(this.__wbg_ptr, css_width, css_height, pixel_ratio);
146
+ }
147
+ /**
148
+ * `[x, y, z]` as JSON; true when the camera moved.
149
+ * @param {string} position_json
150
+ * @returns {boolean}
151
+ */
152
+ setCameraPosition(position_json) {
153
+ const ptr0 = passStringToWasm0(position_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
154
+ const len0 = WASM_VECTOR_LEN;
155
+ const ret = wasm.canvas3d_setCameraPosition(this.__wbg_ptr, ptr0, len0);
156
+ if (ret[2]) {
157
+ throw takeFromExternrefTable0(ret[1]);
158
+ }
159
+ return ret[0] !== 0;
160
+ }
161
+ /**
162
+ * @param {boolean} reduced
163
+ */
164
+ setReducedMotion(reduced) {
165
+ wasm.canvas3d_setReducedMotion(this.__wbg_ptr, reduced);
166
+ }
167
+ /**
168
+ * `node_json`: the 3D render node; `theme_json`: the page's resolved canvas theme, or `null` for none.
169
+ * @param {string} node_json
170
+ * @param {string} theme_json
171
+ */
172
+ setScene(node_json, theme_json) {
173
+ const ptr0 = passStringToWasm0(node_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
174
+ const len0 = WASM_VECTOR_LEN;
175
+ const ptr1 = passStringToWasm0(theme_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
176
+ const len1 = WASM_VECTOR_LEN;
177
+ const ret = wasm.canvas3d_setScene(this.__wbg_ptr, ptr0, len0, ptr1, len1);
178
+ if (ret[1]) {
179
+ throw takeFromExternrefTable0(ret[0]);
180
+ }
181
+ }
182
+ /**
183
+ * False when this canvas runs on the WebGL2 fallback (no GPU drawables there).
184
+ * @returns {boolean}
185
+ */
186
+ webgpu() {
187
+ const ret = wasm.canvas3d_webgpu(this.__wbg_ptr);
188
+ return ret !== 0;
189
+ }
190
+ /**
191
+ * @param {number} delta_y
192
+ * @returns {boolean}
193
+ */
194
+ wheel(delta_y) {
195
+ const ret = wasm.canvas3d_wheel(this.__wbg_ptr, delta_y);
196
+ return ret !== 0;
197
+ }
198
+ }
199
+ if (Symbol.dispose) Canvas3D.prototype[Symbol.dispose] = Canvas3D.prototype.free;
200
+
3
201
  /**
4
202
  * The encrypted credential store for a host whose rows answer asynchronously: the host lists its rows and `load`s them,
5
203
  * runs an operation, then applies `takeWrites()` to its medium in order. See `credentials::VaultApi`.
@@ -408,6 +606,29 @@ export class CredentialVault {
408
606
  }
409
607
  if (Symbol.dispose) CredentialVault.prototype[Symbol.dispose] = CredentialVault.prototype.free;
410
608
 
609
+ export class GpuHost {
610
+ __destroy_into_raw() {
611
+ const ptr = this.__wbg_ptr;
612
+ this.__wbg_ptr = 0;
613
+ GpuHostFinalization.unregister(this);
614
+ return ptr;
615
+ }
616
+ free() {
617
+ const ptr = this.__destroy_into_raw();
618
+ wasm.__wbg_gpuhost_free(ptr, 0);
619
+ }
620
+ closeAll() {
621
+ wasm.gpuhost_closeAll(this.__wbg_ptr);
622
+ }
623
+ constructor() {
624
+ const ret = wasm.gpuhost_new();
625
+ this.__wbg_ptr = ret;
626
+ GpuHostFinalization.register(this, this.__wbg_ptr, this);
627
+ return this;
628
+ }
629
+ }
630
+ if (Symbol.dispose) GpuHost.prototype[Symbol.dispose] = GpuHost.prototype.free;
631
+
411
632
  export class Kernel {
412
633
  __destroy_into_raw() {
413
634
  const ptr = this.__wbg_ptr;
@@ -580,6 +801,38 @@ export class Kernel {
580
801
  wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
581
802
  }
582
803
  }
804
+ /**
805
+ * Dispatch a held completion: `event` on `traitName` with the payload held under `heldPayload`, taken once.
806
+ * @param {string} trait_name
807
+ * @param {string | null | undefined} entity_id
808
+ * @param {string} event
809
+ * @param {number} held_payload
810
+ * @returns {string}
811
+ */
812
+ dispatchHeld(trait_name, entity_id, event, held_payload) {
813
+ let deferred5_0;
814
+ let deferred5_1;
815
+ try {
816
+ const ptr0 = passStringToWasm0(trait_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
817
+ const len0 = WASM_VECTOR_LEN;
818
+ var ptr1 = isLikeNone(entity_id) ? 0 : passStringToWasm0(entity_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
819
+ var len1 = WASM_VECTOR_LEN;
820
+ const ptr2 = passStringToWasm0(event, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
821
+ const len2 = WASM_VECTOR_LEN;
822
+ const ret = wasm.kernel_dispatchHeld(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, held_payload);
823
+ var ptr4 = ret[0];
824
+ var len4 = ret[1];
825
+ if (ret[3]) {
826
+ ptr4 = 0; len4 = 0;
827
+ throw takeFromExternrefTable0(ret[2]);
828
+ }
829
+ deferred5_0 = ptr4;
830
+ deferred5_1 = len4;
831
+ return getStringFromWasm0(ptr4, len4);
832
+ } finally {
833
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
834
+ }
835
+ }
583
836
  /**
584
837
  * The kernel's dispatch mode for a registered trait, as JSON text.
585
838
  * @param {string} trait_name
@@ -609,11 +862,12 @@ export class Kernel {
609
862
  * @param {string} seeds_json
610
863
  * @param {string | null} [entity_id]
611
864
  * @param {string | null} [payload_json]
865
+ * @param {string | null} [route]
612
866
  * @returns {string}
613
867
  */
614
- dispatchMount(seeds_json, entity_id, payload_json) {
615
- let deferred5_0;
616
- let deferred5_1;
868
+ dispatchMount(seeds_json, entity_id, payload_json, route) {
869
+ let deferred6_0;
870
+ let deferred6_1;
617
871
  try {
618
872
  const ptr0 = passStringToWasm0(seeds_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
619
873
  const len0 = WASM_VECTOR_LEN;
@@ -621,19 +875,33 @@ export class Kernel {
621
875
  var len1 = WASM_VECTOR_LEN;
622
876
  var ptr2 = isLikeNone(payload_json) ? 0 : passStringToWasm0(payload_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
623
877
  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];
878
+ var ptr3 = isLikeNone(route) ? 0 : passStringToWasm0(route, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
879
+ var len3 = WASM_VECTOR_LEN;
880
+ const ret = wasm.kernel_dispatchMount(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
881
+ var ptr5 = ret[0];
882
+ var len5 = ret[1];
627
883
  if (ret[3]) {
628
- ptr4 = 0; len4 = 0;
884
+ ptr5 = 0; len5 = 0;
629
885
  throw takeFromExternrefTable0(ret[2]);
630
886
  }
631
- deferred5_0 = ptr4;
632
- deferred5_1 = len4;
633
- return getStringFromWasm0(ptr4, len4);
887
+ deferred6_0 = ptr5;
888
+ deferred6_1 = len5;
889
+ return getStringFromWasm0(ptr5, len5);
634
890
  } finally {
635
- wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
891
+ wasm.__wbindgen_free(deferred6_0, deferred6_1, 1);
892
+ }
893
+ }
894
+ /**
895
+ * Drop a held completion payload no dispatch will take (the host could not deliver it).
896
+ * @param {number} held_payload
897
+ * @returns {boolean}
898
+ */
899
+ dropHeldPayload(held_payload) {
900
+ const ret = wasm.kernel_dropHeldPayload(this.__wbg_ptr, held_payload);
901
+ if (ret[2]) {
902
+ throw takeFromExternrefTable0(ret[1]);
636
903
  }
904
+ return ret[0] !== 0;
637
905
  }
638
906
  /**
639
907
  * @param {number} flight
@@ -795,6 +1063,17 @@ export class Kernel {
795
1063
  wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
796
1064
  }
797
1065
  }
1066
+ /**
1067
+ * Install the GPU answerer: from now on every `gpu/` ask is held in the kernel and answered here in ask order, and
1068
+ * each outcome's route event is handed to `onCompletion` (see [`drain_client_gpu`]) for the host to dispatch with
1069
+ * `dispatchHeld`, so no handle or byte crosses to JavaScript.
1070
+ * @param {GpuHost} gpu
1071
+ * @param {Function} on_completion
1072
+ */
1073
+ installGpu(gpu, on_completion) {
1074
+ _assertClass(gpu, GpuHost);
1075
+ wasm.kernel_installGpu(this.__wbg_ptr, gpu.__wbg_ptr, on_completion);
1076
+ }
798
1077
  /**
799
1078
  * @returns {string}
800
1079
  */
@@ -1079,20 +1358,6 @@ export class Kernel {
1079
1358
  setHostFansOut(fans_out) {
1080
1359
  wasm.kernel_setHostFansOut(this.__wbg_ptr, fans_out);
1081
1360
  }
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
1361
  /**
1097
1362
  * Carry each hop's `@entity` before and after it on the dispatch's transitions (`observed`), for a verifier
1098
1363
  * judging `@ensures`. Off by default (EXEC-STEP-10).
@@ -1112,6 +1377,13 @@ export class Kernel {
1112
1377
  throw takeFromExternrefTable0(ret[0]);
1113
1378
  }
1114
1379
  }
1380
+ /**
1381
+ * Record each dispatch as a trace item while on, for the host's `program/live { kind: "trace" }` streams.
1382
+ * @param {boolean} on
1383
+ */
1384
+ setTraceOn(on) {
1385
+ wasm.kernel_setTraceOn(this.__wbg_ptr, on);
1386
+ }
1115
1387
  /**
1116
1388
  * The host's report of whether a trait's rendered output is on screen; gates its `[visible]` ticks.
1117
1389
  * @param {string} trait_name
@@ -1122,6 +1394,18 @@ export class Kernel {
1122
1394
  const len0 = WASM_VECTOR_LEN;
1123
1395
  wasm.kernel_setTraitOnScreen(this.__wbg_ptr, ptr0, len0, on_screen);
1124
1396
  }
1397
+ /**
1398
+ * The page's locale `i18n/t` paints in when a dispatch names none; the program carries its own messages.
1399
+ * @param {string | null} [locale]
1400
+ */
1401
+ setViewerLocale(locale) {
1402
+ var ptr0 = isLikeNone(locale) ? 0 : passStringToWasm0(locale, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1403
+ var len0 = WASM_VECTOR_LEN;
1404
+ const ret = wasm.kernel_setViewerLocale(this.__wbg_ptr, ptr0, len0);
1405
+ if (ret[1]) {
1406
+ throw takeFromExternrefTable0(ret[0]);
1407
+ }
1408
+ }
1125
1409
  /**
1126
1410
  * @returns {string}
1127
1411
  */
@@ -1167,6 +1451,28 @@ export class Kernel {
1167
1451
  wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
1168
1452
  }
1169
1453
  }
1454
+ /**
1455
+ * The trace items recorded since the last take, in dispatch order: a JSON array.
1456
+ * @returns {string}
1457
+ */
1458
+ takeTrace() {
1459
+ let deferred2_0;
1460
+ let deferred2_1;
1461
+ try {
1462
+ const ret = wasm.kernel_takeTrace(this.__wbg_ptr);
1463
+ var ptr1 = ret[0];
1464
+ var len1 = ret[1];
1465
+ if (ret[3]) {
1466
+ ptr1 = 0; len1 = 0;
1467
+ throw takeFromExternrefTable0(ret[2]);
1468
+ }
1469
+ deferred2_0 = ptr1;
1470
+ deferred2_1 = len1;
1471
+ return getStringFromWasm0(ptr1, len1);
1472
+ } finally {
1473
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1474
+ }
1475
+ }
1170
1476
  /**
1171
1477
  * @param {string} trait_name
1172
1478
  * @param {string} tick_name
@@ -1577,42 +1883,181 @@ export class MemoryStore {
1577
1883
  }
1578
1884
  if (Symbol.dispose) MemoryStore.prototype[Symbol.dispose] = MemoryStore.prototype.free;
1579
1885
 
1580
- /**
1581
- * The server role: `start` a request, answer the I/O it asks for, `resume` the flight until it is done.
1582
- */
1583
- export class Server {
1886
+ export class SceneCanvas {
1584
1887
  static __wrap(ptr) {
1585
- const obj = Object.create(Server.prototype);
1888
+ const obj = Object.create(SceneCanvas.prototype);
1586
1889
  obj.__wbg_ptr = ptr;
1587
- ServerFinalization.register(obj, obj.__wbg_ptr, obj);
1890
+ SceneCanvasFinalization.register(obj, obj.__wbg_ptr, obj);
1588
1891
  return obj;
1589
1892
  }
1590
1893
  __destroy_into_raw() {
1591
1894
  const ptr = this.__wbg_ptr;
1592
1895
  this.__wbg_ptr = 0;
1593
- ServerFinalization.unregister(this);
1896
+ SceneCanvasFinalization.unregister(this);
1594
1897
  return ptr;
1595
1898
  }
1596
1899
  free() {
1597
1900
  const ptr = this.__destroy_into_raw();
1598
- wasm.__wbg_server_free(ptr, 0);
1901
+ wasm.__wbg_scenecanvas_free(ptr, 0);
1599
1902
  }
1600
1903
  /**
1601
- * @param {number} flight
1602
- * @returns {boolean}
1904
+ * @param {HTMLCanvasElement} canvas
1905
+ * @returns {Promise<SceneCanvas>}
1603
1906
  */
1604
- abandon(flight) {
1605
- const ret = wasm.server_abandon(this.__wbg_ptr, flight);
1606
- if (ret[2]) {
1607
- throw takeFromExternrefTable0(ret[1]);
1608
- }
1609
- return ret[0] !== 0;
1907
+ static create(canvas) {
1908
+ const ret = wasm.scenecanvas_create(canvas);
1909
+ return ret;
1610
1910
  }
1611
1911
  /**
1612
- * @param {string} side
1613
- * @returns {string}
1912
+ * @param {number} x
1913
+ * @param {number} y
1614
1914
  */
1615
- bootMounts(side) {
1915
+ doubleTap(x, y) {
1916
+ wasm.scenecanvas_doubleTap(this.__wbg_ptr, x, y);
1917
+ }
1918
+ /**
1919
+ * Advances the scene clock to `now_ms`; true while the page should keep drawing.
1920
+ * @param {number} now_ms
1921
+ * @returns {boolean}
1922
+ */
1923
+ frame(now_ms) {
1924
+ const ret = wasm.scenecanvas_frame(this.__wbg_ptr, now_ms);
1925
+ return ret !== 0;
1926
+ }
1927
+ /**
1928
+ * A pointer event in CSS pixels: `touch-down`, `touch-move`, `touch-up` or `touch-cancel`.
1929
+ * @param {string} kind
1930
+ * @param {number} x
1931
+ * @param {number} y
1932
+ * @param {number} button
1933
+ */
1934
+ input(kind, x, y, button) {
1935
+ const ptr0 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1936
+ const len0 = WASM_VECTOR_LEN;
1937
+ wasm.scenecanvas_input(this.__wbg_ptr, ptr0, len0, x, y, button);
1938
+ }
1939
+ render() {
1940
+ const ret = wasm.scenecanvas_render(this.__wbg_ptr);
1941
+ if (ret[1]) {
1942
+ throw takeFromExternrefTable0(ret[0]);
1943
+ }
1944
+ }
1945
+ /**
1946
+ * @param {number} css_width
1947
+ * @param {number} css_height
1948
+ * @param {number} pixel_ratio
1949
+ */
1950
+ resize(css_width, css_height, pixel_ratio) {
1951
+ const ret = wasm.scenecanvas_resize(this.__wbg_ptr, css_width, css_height, pixel_ratio);
1952
+ if (ret[1]) {
1953
+ throw takeFromExternrefTable0(ret[0]);
1954
+ }
1955
+ }
1956
+ /**
1957
+ * @param {boolean} enabled
1958
+ */
1959
+ setMotion(enabled) {
1960
+ wasm.scenecanvas_setMotion(this.__wbg_ptr, enabled);
1961
+ }
1962
+ /**
1963
+ * `node_json`: the render node (`{ "type": "physics-canvas", … }`).
1964
+ * @param {string} node_json
1965
+ */
1966
+ setScene(node_json) {
1967
+ const ptr0 = passStringToWasm0(node_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
1968
+ const len0 = WASM_VECTOR_LEN;
1969
+ const ret = wasm.scenecanvas_setScene(this.__wbg_ptr, ptr0, len0);
1970
+ if (ret[1]) {
1971
+ throw takeFromExternrefTable0(ret[0]);
1972
+ }
1973
+ }
1974
+ /**
1975
+ * The scene events input queued, as JSON `[{ "event", "payload" }]`.
1976
+ * @returns {string}
1977
+ */
1978
+ takeEvents() {
1979
+ let deferred1_0;
1980
+ let deferred1_1;
1981
+ try {
1982
+ const ret = wasm.scenecanvas_takeEvents(this.__wbg_ptr);
1983
+ deferred1_0 = ret[0];
1984
+ deferred1_1 = ret[1];
1985
+ return getStringFromWasm0(ret[0], ret[1]);
1986
+ } finally {
1987
+ wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
1988
+ }
1989
+ }
1990
+ /**
1991
+ * @returns {boolean}
1992
+ */
1993
+ webgpu() {
1994
+ const ret = wasm.scenecanvas_webgpu(this.__wbg_ptr);
1995
+ return ret !== 0;
1996
+ }
1997
+ /**
1998
+ * Whether the scene took the zoom; the page scrolls when it did not.
1999
+ * @param {number} factor
2000
+ * @param {number} x
2001
+ * @param {number} y
2002
+ * @returns {boolean}
2003
+ */
2004
+ zoom(factor, x, y) {
2005
+ const ret = wasm.scenecanvas_zoom(this.__wbg_ptr, factor, x, y);
2006
+ return ret !== 0;
2007
+ }
2008
+ }
2009
+ if (Symbol.dispose) SceneCanvas.prototype[Symbol.dispose] = SceneCanvas.prototype.free;
2010
+
2011
+ /**
2012
+ * The server role: `start` a request, answer the I/O it asks for, `resume` the flight until it is done.
2013
+ */
2014
+ export class Server {
2015
+ static __wrap(ptr) {
2016
+ const obj = Object.create(Server.prototype);
2017
+ obj.__wbg_ptr = ptr;
2018
+ ServerFinalization.register(obj, obj.__wbg_ptr, obj);
2019
+ return obj;
2020
+ }
2021
+ __destroy_into_raw() {
2022
+ const ptr = this.__wbg_ptr;
2023
+ this.__wbg_ptr = 0;
2024
+ ServerFinalization.unregister(this);
2025
+ return ptr;
2026
+ }
2027
+ free() {
2028
+ const ptr = this.__destroy_into_raw();
2029
+ wasm.__wbg_server_free(ptr, 0);
2030
+ }
2031
+ /**
2032
+ * @param {number} flight
2033
+ * @returns {boolean}
2034
+ */
2035
+ abandon(flight) {
2036
+ const ret = wasm.server_abandon(this.__wbg_ptr, flight);
2037
+ if (ret[2]) {
2038
+ throw takeFromExternrefTable0(ret[1]);
2039
+ }
2040
+ return ret[0] !== 0;
2041
+ }
2042
+ /**
2043
+ * Answer the held `gpu/` ask `ticket` (an `IoRequestWire` of kind `gpu`): resolves to the `IoAnswerWire` JSON to
2044
+ * reply with. A deferred completion is handed to `onCompletion` (see [`answer_held`]).
2045
+ * @param {number} ticket
2046
+ * @param {Function} on_completion
2047
+ * @returns {Promise<any>}
2048
+ */
2049
+ answerGpu(ticket, on_completion) {
2050
+ const ret = wasm.server_answerGpu(this.__wbg_ptr, ticket, on_completion);
2051
+ if (ret[2]) {
2052
+ throw takeFromExternrefTable0(ret[1]);
2053
+ }
2054
+ return takeFromExternrefTable0(ret[0]);
2055
+ }
2056
+ /**
2057
+ * @param {string} side
2058
+ * @returns {string}
2059
+ */
2060
+ bootMounts(side) {
1616
2061
  let deferred3_0;
1617
2062
  let deferred3_1;
1618
2063
  try {
@@ -1696,6 +2141,18 @@ export class Server {
1696
2141
  wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
1697
2142
  }
1698
2143
  }
2144
+ /**
2145
+ * Drop a held completion payload the host will not start (its call was cancelled).
2146
+ * @param {number} ticket
2147
+ * @returns {boolean}
2148
+ */
2149
+ dropHeldPayload(ticket) {
2150
+ const ret = wasm.server_dropHeldPayload(this.__wbg_ptr, ticket);
2151
+ if (ret[2]) {
2152
+ throw takeFromExternrefTable0(ret[1]);
2153
+ }
2154
+ return ret[0] !== 0;
2155
+ }
1699
2156
  /**
1700
2157
  * @param {string} url
1701
2158
  * @returns {boolean}
@@ -1791,6 +2248,15 @@ export class Server {
1791
2248
  const ret = wasm.server_inFlight(this.__wbg_ptr);
1792
2249
  return ret >>> 0;
1793
2250
  }
2251
+ /**
2252
+ * Install the GPU answerer: from now on the server holds every `gpu/` ask, and the host answers it by ticket
2253
+ * with `answerGpu`, so no argument or answer crosses to JavaScript.
2254
+ * @param {GpuHost} gpu
2255
+ */
2256
+ installGpu(gpu) {
2257
+ _assertClass(gpu, GpuHost);
2258
+ wasm.server_installGpu(this.__wbg_ptr, gpu.__wbg_ptr);
2259
+ }
1794
2260
  /**
1795
2261
  * @returns {string}
1796
2262
  */
@@ -2142,20 +2608,6 @@ export class Server {
2142
2608
  throw takeFromExternrefTable0(ret[0]);
2143
2609
  }
2144
2610
  }
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
2611
  /**
2160
2612
  * @param {string} anchors_json
2161
2613
  * @returns {string}
@@ -2481,6 +2933,75 @@ export function eventWires(schema_json) {
2481
2933
  }
2482
2934
  }
2483
2935
 
2936
+ /**
2937
+ * @param {string} layer_json
2938
+ * @param {number} epoch_now_ms
2939
+ * @param {string} dimension
2940
+ * @param {number} tile_width
2941
+ * @returns {string}
2942
+ */
2943
+ export function expandFxLayer(layer_json, epoch_now_ms, dimension, tile_width) {
2944
+ let deferred4_0;
2945
+ let deferred4_1;
2946
+ try {
2947
+ const ptr0 = passStringToWasm0(layer_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2948
+ const len0 = WASM_VECTOR_LEN;
2949
+ const ptr1 = passStringToWasm0(dimension, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2950
+ const len1 = WASM_VECTOR_LEN;
2951
+ const ret = wasm.expandFxLayer(ptr0, len0, epoch_now_ms, ptr1, len1, tile_width);
2952
+ var ptr3 = ret[0];
2953
+ var len3 = ret[1];
2954
+ if (ret[3]) {
2955
+ ptr3 = 0; len3 = 0;
2956
+ throw takeFromExternrefTable0(ret[2]);
2957
+ }
2958
+ deferred4_0 = ptr3;
2959
+ deferred4_1 = len3;
2960
+ return getStringFromWasm0(ptr3, len3);
2961
+ } finally {
2962
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
2963
+ }
2964
+ }
2965
+
2966
+ /**
2967
+ * @param {string} seed
2968
+ * @param {number} salt
2969
+ * @returns {number}
2970
+ */
2971
+ export function fxHash01(seed, salt) {
2972
+ const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2973
+ const len0 = WASM_VECTOR_LEN;
2974
+ const ret = wasm.fxHash01(ptr0, len0, salt);
2975
+ return ret;
2976
+ }
2977
+
2978
+ /**
2979
+ * @param {string} view_json
2980
+ * @param {number} epoch_now_ms
2981
+ * @param {number} tick_ms
2982
+ * @returns {string}
2983
+ */
2984
+ export function fxLifecycle(view_json, epoch_now_ms, tick_ms) {
2985
+ let deferred3_0;
2986
+ let deferred3_1;
2987
+ try {
2988
+ const ptr0 = passStringToWasm0(view_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2989
+ const len0 = WASM_VECTOR_LEN;
2990
+ const ret = wasm.fxLifecycle(ptr0, len0, epoch_now_ms, tick_ms);
2991
+ var ptr2 = ret[0];
2992
+ var len2 = ret[1];
2993
+ if (ret[3]) {
2994
+ ptr2 = 0; len2 = 0;
2995
+ throw takeFromExternrefTable0(ret[2]);
2996
+ }
2997
+ deferred3_0 = ptr2;
2998
+ deferred3_1 = len2;
2999
+ return getStringFromWasm0(ptr2, len2);
3000
+ } finally {
3001
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
3002
+ }
3003
+ }
3004
+
2484
3005
  /**
2485
3006
  * Install the language data a host assembles from its installed `@almadar/core` and `@almadar/std`
2486
3007
  * (`readLanguageBundle`): the operator table that routes `program/*` and the other host effects.
@@ -2652,6 +3173,34 @@ export function report_panics() {
2652
3173
  wasm.report_panics();
2653
3174
  }
2654
3175
 
3176
+ /**
3177
+ * @param {string} item_json
3178
+ * @param {string | null} [presets_json]
3179
+ * @returns {string}
3180
+ */
3181
+ export function resolveFxView(item_json, presets_json) {
3182
+ let deferred4_0;
3183
+ let deferred4_1;
3184
+ try {
3185
+ const ptr0 = passStringToWasm0(item_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3186
+ const len0 = WASM_VECTOR_LEN;
3187
+ var ptr1 = isLikeNone(presets_json) ? 0 : passStringToWasm0(presets_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3188
+ var len1 = WASM_VECTOR_LEN;
3189
+ const ret = wasm.resolveFxView(ptr0, len0, ptr1, len1);
3190
+ var ptr3 = ret[0];
3191
+ var len3 = ret[1];
3192
+ if (ret[3]) {
3193
+ ptr3 = 0; len3 = 0;
3194
+ throw takeFromExternrefTable0(ret[2]);
3195
+ }
3196
+ deferred4_0 = ptr3;
3197
+ deferred4_1 = len3;
3198
+ return getStringFromWasm0(ptr3, len3);
3199
+ } finally {
3200
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
3201
+ }
3202
+ }
3203
+
2655
3204
  /**
2656
3205
  * What a `@user`/`@payload`/`@config`/`@now` term folds to for a row predicate (`RowBindingWire` as JSON).
2657
3206
  * @param {string} term
@@ -2750,72 +3299,46 @@ export function scopeRows(bindings_json, rows_json, policy_json, filter_json, en
2750
3299
  }
2751
3300
 
2752
3301
  /**
2753
- * @param {string} site_json
2754
- * @param {string} key
2755
- * @param {string} op
2756
- * @param {string} args_json
2757
- * @param {string} outcome_json
3302
+ * @param {string} matrix_json
3303
+ * @param {number} x
3304
+ * @param {number} y
2758
3305
  * @returns {string}
2759
3306
  */
2760
- export function substrateCompletionEvent(site_json, key, op, args_json, outcome_json) {
2761
- let deferred7_0;
2762
- let deferred7_1;
3307
+ export function skinApplyAffine(matrix_json, x, y) {
3308
+ let deferred3_0;
3309
+ let deferred3_1;
2763
3310
  try {
2764
- const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3311
+ const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2765
3312
  const len0 = WASM_VECTOR_LEN;
2766
- const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2767
- 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];
3313
+ const ret = wasm.skinApplyAffine(ptr0, len0, x, y);
3314
+ var ptr2 = ret[0];
3315
+ var len2 = ret[1];
2777
3316
  if (ret[3]) {
2778
- ptr6 = 0; len6 = 0;
3317
+ ptr2 = 0; len2 = 0;
2779
3318
  throw takeFromExternrefTable0(ret[2]);
2780
3319
  }
2781
- deferred7_0 = ptr6;
2782
- deferred7_1 = len6;
2783
- return getStringFromWasm0(ptr6, len6);
3320
+ deferred3_0 = ptr2;
3321
+ deferred3_1 = len2;
3322
+ return getStringFromWasm0(ptr2, len2);
2784
3323
  } finally {
2785
- wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
3324
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
2786
3325
  }
2787
3326
  }
2788
3327
 
2789
3328
  /**
2790
- * Whether the Chrome match pattern `pattern` matches `url`.
2791
- * @param {string} pattern
2792
- * @param {string} url
2793
- * @returns {boolean}
2794
- */
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;
2802
- }
2803
-
2804
- /**
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
3329
+ * @param {string} a_json
3330
+ * @param {string} b_json
2808
3331
  * @returns {string}
2809
3332
  */
2810
- export function traceEffects(context_json, effects_json) {
3333
+ export function skinComposeAffine(a_json, b_json) {
2811
3334
  let deferred4_0;
2812
3335
  let deferred4_1;
2813
3336
  try {
2814
- const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3337
+ const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2815
3338
  const len0 = WASM_VECTOR_LEN;
2816
- const ptr1 = passStringToWasm0(effects_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3339
+ const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
2817
3340
  const len1 = WASM_VECTOR_LEN;
2818
- const ret = wasm.traceEffects(ptr0, len0, ptr1, len1);
3341
+ const ret = wasm.skinComposeAffine(ptr0, len0, ptr1, len1);
2819
3342
  var ptr3 = ret[0];
2820
3343
  var len3 = ret[1];
2821
3344
  if (ret[3]) {
@@ -2831,15 +3354,234 @@ export function traceEffects(context_json, effects_json) {
2831
3354
  }
2832
3355
 
2833
3356
  /**
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
3357
+ * @param {string} matrix_json
3358
+ * @param {number} bone
3359
+ * @returns {string}
2836
3360
  */
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]);
3361
+ export function skinInvertAffine(matrix_json, bone) {
3362
+ let deferred3_0;
3363
+ let deferred3_1;
3364
+ try {
3365
+ const ptr0 = passStringToWasm0(matrix_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3366
+ const len0 = WASM_VECTOR_LEN;
3367
+ const ret = wasm.skinInvertAffine(ptr0, len0, bone);
3368
+ var ptr2 = ret[0];
3369
+ var len2 = ret[1];
3370
+ if (ret[3]) {
3371
+ ptr2 = 0; len2 = 0;
3372
+ throw takeFromExternrefTable0(ret[2]);
3373
+ }
3374
+ deferred3_0 = ptr2;
3375
+ deferred3_1 = len2;
3376
+ return getStringFromWasm0(ptr2, len2);
3377
+ } finally {
3378
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
3379
+ }
3380
+ }
3381
+
3382
+ /**
3383
+ * @param {string} src_json
3384
+ * @param {string} dst_json
3385
+ * @returns {string}
3386
+ */
3387
+ export function skinTriangleAffine(src_json, dst_json) {
3388
+ let deferred4_0;
3389
+ let deferred4_1;
3390
+ try {
3391
+ const ptr0 = passStringToWasm0(src_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3392
+ const len0 = WASM_VECTOR_LEN;
3393
+ const ptr1 = passStringToWasm0(dst_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3394
+ const len1 = WASM_VECTOR_LEN;
3395
+ const ret = wasm.skinTriangleAffine(ptr0, len0, ptr1, len1);
3396
+ var ptr3 = ret[0];
3397
+ var len3 = ret[1];
3398
+ if (ret[3]) {
3399
+ ptr3 = 0; len3 = 0;
3400
+ throw takeFromExternrefTable0(ret[2]);
3401
+ }
3402
+ deferred4_0 = ptr3;
3403
+ deferred4_1 = len3;
3404
+ return getStringFromWasm0(ptr3, len3);
3405
+ } finally {
3406
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
3407
+ }
3408
+ }
3409
+
3410
+ /**
3411
+ * @param {string} points_json
3412
+ * @returns {string}
3413
+ */
3414
+ export function skinVertexBounds(points_json) {
3415
+ let deferred3_0;
3416
+ let deferred3_1;
3417
+ try {
3418
+ const ptr0 = passStringToWasm0(points_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3419
+ const len0 = WASM_VECTOR_LEN;
3420
+ const ret = wasm.skinVertexBounds(ptr0, len0);
3421
+ var ptr2 = ret[0];
3422
+ var len2 = ret[1];
3423
+ if (ret[3]) {
3424
+ ptr2 = 0; len2 = 0;
3425
+ throw takeFromExternrefTable0(ret[2]);
3426
+ }
3427
+ deferred3_0 = ptr2;
3428
+ deferred3_1 = len2;
3429
+ return getStringFromWasm0(ptr2, len2);
3430
+ } finally {
3431
+ wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
3432
+ }
3433
+ }
3434
+
3435
+ /**
3436
+ * @param {string} mesh_json
3437
+ * @param {string} bind_json
3438
+ * @param {string} current_json
3439
+ * @returns {string}
3440
+ */
3441
+ export function skinVertices(mesh_json, bind_json, current_json) {
3442
+ let deferred5_0;
3443
+ let deferred5_1;
3444
+ try {
3445
+ const ptr0 = passStringToWasm0(mesh_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3446
+ const len0 = WASM_VECTOR_LEN;
3447
+ const ptr1 = passStringToWasm0(bind_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3448
+ const len1 = WASM_VECTOR_LEN;
3449
+ const ptr2 = passStringToWasm0(current_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3450
+ const len2 = WASM_VECTOR_LEN;
3451
+ const ret = wasm.skinVertices(ptr0, len0, ptr1, len1, ptr2, len2);
3452
+ var ptr4 = ret[0];
3453
+ var len4 = ret[1];
3454
+ if (ret[3]) {
3455
+ ptr4 = 0; len4 = 0;
3456
+ throw takeFromExternrefTable0(ret[2]);
3457
+ }
3458
+ deferred5_0 = ptr4;
3459
+ deferred5_1 = len4;
3460
+ return getStringFromWasm0(ptr4, len4);
3461
+ } finally {
3462
+ wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
3463
+ }
3464
+ }
3465
+
3466
+ /**
3467
+ * @param {string} bones_json
3468
+ * @param {string} pose_json
3469
+ * @returns {string}
3470
+ */
3471
+ export function skinWorldMatrices(bones_json, pose_json) {
3472
+ let deferred4_0;
3473
+ let deferred4_1;
3474
+ try {
3475
+ const ptr0 = passStringToWasm0(bones_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3476
+ const len0 = WASM_VECTOR_LEN;
3477
+ const ptr1 = passStringToWasm0(pose_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3478
+ const len1 = WASM_VECTOR_LEN;
3479
+ const ret = wasm.skinWorldMatrices(ptr0, len0, ptr1, len1);
3480
+ var ptr3 = ret[0];
3481
+ var len3 = ret[1];
3482
+ if (ret[3]) {
3483
+ ptr3 = 0; len3 = 0;
3484
+ throw takeFromExternrefTable0(ret[2]);
3485
+ }
3486
+ deferred4_0 = ptr3;
3487
+ deferred4_1 = len3;
3488
+ return getStringFromWasm0(ptr3, len3);
3489
+ } finally {
3490
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
3491
+ }
3492
+ }
3493
+
3494
+ /**
3495
+ * @param {string} site_json
3496
+ * @param {string} key
3497
+ * @param {string} op
3498
+ * @param {string} args_json
3499
+ * @param {string} outcome_json
3500
+ * @returns {string}
3501
+ */
3502
+ export function substrateCompletionEvent(site_json, key, op, args_json, outcome_json) {
3503
+ let deferred7_0;
3504
+ let deferred7_1;
3505
+ try {
3506
+ const ptr0 = passStringToWasm0(site_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3507
+ const len0 = WASM_VECTOR_LEN;
3508
+ const ptr1 = passStringToWasm0(key, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3509
+ const len1 = WASM_VECTOR_LEN;
3510
+ const ptr2 = passStringToWasm0(op, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3511
+ const len2 = WASM_VECTOR_LEN;
3512
+ const ptr3 = passStringToWasm0(args_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3513
+ const len3 = WASM_VECTOR_LEN;
3514
+ const ptr4 = passStringToWasm0(outcome_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3515
+ const len4 = WASM_VECTOR_LEN;
3516
+ const ret = wasm.substrateCompletionEvent(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
3517
+ var ptr6 = ret[0];
3518
+ var len6 = ret[1];
3519
+ if (ret[3]) {
3520
+ ptr6 = 0; len6 = 0;
3521
+ throw takeFromExternrefTable0(ret[2]);
3522
+ }
3523
+ deferred7_0 = ptr6;
3524
+ deferred7_1 = len6;
3525
+ return getStringFromWasm0(ptr6, len6);
3526
+ } finally {
3527
+ wasm.__wbindgen_free(deferred7_0, deferred7_1, 1);
3528
+ }
3529
+ }
3530
+
3531
+ /**
3532
+ * Whether the Chrome match pattern `pattern` matches `url`.
3533
+ * @param {string} pattern
3534
+ * @param {string} url
3535
+ * @returns {boolean}
3536
+ */
3537
+ export function tabUrlMatches(pattern, url) {
3538
+ const ptr0 = passStringToWasm0(pattern, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3539
+ const len0 = WASM_VECTOR_LEN;
3540
+ const ptr1 = passStringToWasm0(url, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3541
+ const len1 = WASM_VECTOR_LEN;
3542
+ const ret = wasm.tabUrlMatches(ptr0, len0, ptr1, len1);
3543
+ return ret !== 0;
3544
+ }
3545
+
3546
+ /**
3547
+ * Effects run in order against a row (`TraceEffectsWire` as JSON): a trace per effect, the events raised, the writes made.
3548
+ * @param {string} context_json
3549
+ * @param {string} effects_json
3550
+ * @returns {string}
3551
+ */
3552
+ export function traceEffects(context_json, effects_json) {
3553
+ let deferred4_0;
3554
+ let deferred4_1;
3555
+ try {
3556
+ const ptr0 = passStringToWasm0(context_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3557
+ const len0 = WASM_VECTOR_LEN;
3558
+ const ptr1 = passStringToWasm0(effects_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3559
+ const len1 = WASM_VECTOR_LEN;
3560
+ const ret = wasm.traceEffects(ptr0, len0, ptr1, len1);
3561
+ var ptr3 = ret[0];
3562
+ var len3 = ret[1];
3563
+ if (ret[3]) {
3564
+ ptr3 = 0; len3 = 0;
3565
+ throw takeFromExternrefTable0(ret[2]);
3566
+ }
3567
+ deferred4_0 = ptr3;
3568
+ deferred4_1 = len3;
3569
+ return getStringFromWasm0(ptr3, len3);
3570
+ } finally {
3571
+ wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
3572
+ }
3573
+ }
3574
+
3575
+ /**
3576
+ * The kernel's verdict on language packs (`[{ package, definition }]` as JSON): throws the refusal that names each pack, section and word.
3577
+ * @param {string} packs_json
3578
+ */
3579
+ export function validatePacks(packs_json) {
3580
+ const ptr0 = passStringToWasm0(packs_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3581
+ const len0 = WASM_VECTOR_LEN;
3582
+ const ret = wasm.validatePacks(ptr0, len0);
3583
+ if (ret[1]) {
3584
+ throw takeFromExternrefTable0(ret[0]);
2843
3585
  }
2844
3586
  }
2845
3587
  function __wbg_get_imports() {
@@ -2849,136 +3591,2173 @@ function __wbg_get_imports() {
2849
3591
  const ret = Error(getStringFromWasm0(arg0, arg1));
2850
3592
  return ret;
2851
3593
  },
2852
- __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
2853
- const ret = typeof(arg0) === 'function';
2854
- return ret;
3594
+ __wbg_Window_defb2c76b3875a73: function(arg0) {
3595
+ const ret = arg0.Window;
3596
+ return ret;
3597
+ },
3598
+ __wbg_WorkerGlobalScope_184e45d6565eb3f0: function(arg0) {
3599
+ const ret = arg0.WorkerGlobalScope;
3600
+ return ret;
3601
+ },
3602
+ __wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function(arg0) {
3603
+ const v = arg0;
3604
+ const ret = typeof(v) === 'boolean' ? v : undefined;
3605
+ return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
3606
+ },
3607
+ __wbg___wbindgen_debug_string_c25d447a39f5578f: function(arg0, arg1) {
3608
+ const ret = debugString(arg1);
3609
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3610
+ const len1 = WASM_VECTOR_LEN;
3611
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3612
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3613
+ },
3614
+ __wbg___wbindgen_is_function_1ff95bcc5517c252: function(arg0) {
3615
+ const ret = typeof(arg0) === 'function';
3616
+ return ret;
3617
+ },
3618
+ __wbg___wbindgen_is_null_ea9085d691f535d3: function(arg0) {
3619
+ const ret = arg0 === null;
3620
+ return ret;
3621
+ },
3622
+ __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
3623
+ const val = arg0;
3624
+ const ret = typeof(val) === 'object' && val !== null;
3625
+ return ret;
3626
+ },
3627
+ __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
3628
+ const ret = typeof(arg0) === 'string';
3629
+ return ret;
3630
+ },
3631
+ __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
3632
+ const ret = arg0 === undefined;
3633
+ return ret;
3634
+ },
3635
+ __wbg___wbindgen_number_get_394265ed1e1b84ee: function(arg0, arg1) {
3636
+ const obj = arg1;
3637
+ const ret = typeof(obj) === 'number' ? obj : undefined;
3638
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
3639
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
3640
+ },
3641
+ __wbg___wbindgen_string_get_b0ca35b86a603356: function(arg0, arg1) {
3642
+ const obj = arg1;
3643
+ const ret = typeof(obj) === 'string' ? obj : undefined;
3644
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
3645
+ var len1 = WASM_VECTOR_LEN;
3646
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
3647
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
3648
+ },
3649
+ __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
3650
+ throw new Error(getStringFromWasm0(arg0, arg1));
3651
+ },
3652
+ __wbg__wbg_cb_unref_fffb441def202758: function(arg0) {
3653
+ arg0._wbg_cb_unref();
3654
+ },
3655
+ __wbg_activeTexture_92b04d918019d603: function(arg0, arg1) {
3656
+ arg0.activeTexture(arg1 >>> 0);
3657
+ },
3658
+ __wbg_activeTexture_d12958674e97a118: function(arg0, arg1) {
3659
+ arg0.activeTexture(arg1 >>> 0);
3660
+ },
3661
+ __wbg_arrayBuffer_3b637f0fa65c5351: function() { return handleError(function (arg0) {
3662
+ const ret = arg0.arrayBuffer();
3663
+ return ret;
3664
+ }, arguments); },
3665
+ __wbg_attachShader_5f7f4077e124e23b: function(arg0, arg1, arg2) {
3666
+ arg0.attachShader(arg1, arg2);
3667
+ },
3668
+ __wbg_attachShader_8971266b4c9bc514: function(arg0, arg1, arg2) {
3669
+ arg0.attachShader(arg1, arg2);
3670
+ },
3671
+ __wbg_beginComputePass_1fc169dd9fc89475: function(arg0, arg1) {
3672
+ const ret = arg0.beginComputePass(arg1);
3673
+ return ret;
3674
+ },
3675
+ __wbg_beginQuery_042a1f99e870066c: function(arg0, arg1, arg2) {
3676
+ arg0.beginQuery(arg1 >>> 0, arg2);
3677
+ },
3678
+ __wbg_beginRenderPass_8f60a9940800c223: function() { return handleError(function (arg0, arg1) {
3679
+ const ret = arg0.beginRenderPass(arg1);
3680
+ return ret;
3681
+ }, arguments); },
3682
+ __wbg_bindAttribLocation_0fe5da7e01ac0d15: function(arg0, arg1, arg2, arg3, arg4) {
3683
+ arg0.bindAttribLocation(arg1, arg2 >>> 0, getStringFromWasm0(arg3, arg4));
3684
+ },
3685
+ __wbg_bindAttribLocation_94202d7a59ab7863: function(arg0, arg1, arg2, arg3, arg4) {
3686
+ arg0.bindAttribLocation(arg1, arg2 >>> 0, getStringFromWasm0(arg3, arg4));
3687
+ },
3688
+ __wbg_bindBufferRange_f5c29912db0476e9: function(arg0, arg1, arg2, arg3, arg4, arg5) {
3689
+ arg0.bindBufferRange(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
3690
+ },
3691
+ __wbg_bindBuffer_1e00cfb4321ef9a4: function(arg0, arg1, arg2) {
3692
+ arg0.bindBuffer(arg1 >>> 0, arg2);
3693
+ },
3694
+ __wbg_bindBuffer_a01497b1abdcdd9a: function(arg0, arg1, arg2) {
3695
+ arg0.bindBuffer(arg1 >>> 0, arg2);
3696
+ },
3697
+ __wbg_bindFramebuffer_390311eff3896937: function(arg0, arg1, arg2) {
3698
+ arg0.bindFramebuffer(arg1 >>> 0, arg2);
3699
+ },
3700
+ __wbg_bindFramebuffer_658e4b06f7ee8bb4: function(arg0, arg1, arg2) {
3701
+ arg0.bindFramebuffer(arg1 >>> 0, arg2);
3702
+ },
3703
+ __wbg_bindRenderbuffer_75e8469e930840fa: function(arg0, arg1, arg2) {
3704
+ arg0.bindRenderbuffer(arg1 >>> 0, arg2);
3705
+ },
3706
+ __wbg_bindRenderbuffer_c3d0c4b8cd1c3891: function(arg0, arg1, arg2) {
3707
+ arg0.bindRenderbuffer(arg1 >>> 0, arg2);
3708
+ },
3709
+ __wbg_bindSampler_ce608f0de9d31acf: function(arg0, arg1, arg2) {
3710
+ arg0.bindSampler(arg1 >>> 0, arg2);
3711
+ },
3712
+ __wbg_bindTexture_28eff4bbd8aaab54: function(arg0, arg1, arg2) {
3713
+ arg0.bindTexture(arg1 >>> 0, arg2);
3714
+ },
3715
+ __wbg_bindTexture_9b04b1b7c00d4dd6: function(arg0, arg1, arg2) {
3716
+ arg0.bindTexture(arg1 >>> 0, arg2);
3717
+ },
3718
+ __wbg_bindVertexArrayOES_5cad2205a17e8990: function(arg0, arg1) {
3719
+ arg0.bindVertexArrayOES(arg1);
3720
+ },
3721
+ __wbg_bindVertexArray_427eeac0c1764d8a: function(arg0, arg1) {
3722
+ arg0.bindVertexArray(arg1);
3723
+ },
3724
+ __wbg_blendColor_793b560dc69ddd0b: function(arg0, arg1, arg2, arg3, arg4) {
3725
+ arg0.blendColor(arg1, arg2, arg3, arg4);
3726
+ },
3727
+ __wbg_blendColor_eae0cd578a2c7d15: function(arg0, arg1, arg2, arg3, arg4) {
3728
+ arg0.blendColor(arg1, arg2, arg3, arg4);
3729
+ },
3730
+ __wbg_blendEquationSeparate_043e2f50f6ecb2d3: function(arg0, arg1, arg2) {
3731
+ arg0.blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
3732
+ },
3733
+ __wbg_blendEquationSeparate_c7e2b2261c94e1c5: function(arg0, arg1, arg2) {
3734
+ arg0.blendEquationSeparate(arg1 >>> 0, arg2 >>> 0);
3735
+ },
3736
+ __wbg_blendEquation_455b8986ededabc0: function(arg0, arg1) {
3737
+ arg0.blendEquation(arg1 >>> 0);
3738
+ },
3739
+ __wbg_blendEquation_f5c5272993f6cb01: function(arg0, arg1) {
3740
+ arg0.blendEquation(arg1 >>> 0);
3741
+ },
3742
+ __wbg_blendFuncSeparate_37156309688f8f88: function(arg0, arg1, arg2, arg3, arg4) {
3743
+ arg0.blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
3744
+ },
3745
+ __wbg_blendFuncSeparate_3ee6d939a9f3938b: function(arg0, arg1, arg2, arg3, arg4) {
3746
+ arg0.blendFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
3747
+ },
3748
+ __wbg_blendFunc_114dc7056ccfeb8d: function(arg0, arg1, arg2) {
3749
+ arg0.blendFunc(arg1 >>> 0, arg2 >>> 0);
3750
+ },
3751
+ __wbg_blendFunc_a854d7e4459150ba: function(arg0, arg1, arg2) {
3752
+ arg0.blendFunc(arg1 >>> 0, arg2 >>> 0);
3753
+ },
3754
+ __wbg_blitFramebuffer_a1215976f663b058: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
3755
+ arg0.blitFramebuffer(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0);
3756
+ },
3757
+ __wbg_bufferData_073a7c6abef7a55f: function(arg0, arg1, arg2, arg3) {
3758
+ arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
3759
+ },
3760
+ __wbg_bufferData_3d4f29bdfb1fa46c: function(arg0, arg1, arg2, arg3) {
3761
+ arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
3762
+ },
3763
+ __wbg_bufferData_90ef588bac2be2f5: function(arg0, arg1, arg2, arg3) {
3764
+ arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
3765
+ },
3766
+ __wbg_bufferData_ce4f44d56e9ddab5: function(arg0, arg1, arg2, arg3) {
3767
+ arg0.bufferData(arg1 >>> 0, arg2, arg3 >>> 0);
3768
+ },
3769
+ __wbg_bufferSubData_bae930b21e9c1c48: function(arg0, arg1, arg2, arg3) {
3770
+ arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
3771
+ },
3772
+ __wbg_bufferSubData_ce9854d3d337e2cf: function(arg0, arg1, arg2, arg3) {
3773
+ arg0.bufferSubData(arg1 >>> 0, arg2, arg3);
3774
+ },
3775
+ __wbg_buffer_54b87055582c8a81: function(arg0) {
3776
+ const ret = arg0.buffer;
3777
+ return ret;
3778
+ },
3779
+ __wbg_call_a6e5c5dce5018821: function() { return handleError(function (arg0, arg1, arg2) {
3780
+ const ret = arg0.call(arg1, arg2);
3781
+ return ret;
3782
+ }, arguments); },
3783
+ __wbg_canvas3d_new: function(arg0) {
3784
+ const ret = Canvas3D.__wrap(arg0);
3785
+ return ret;
3786
+ },
3787
+ __wbg_clearBuffer_5c4f30438f07155a: function(arg0, arg1, arg2, arg3) {
3788
+ arg0.clearBuffer(arg1, arg2, arg3);
3789
+ },
3790
+ __wbg_clearBuffer_de7e8cd418b56c30: function(arg0, arg1, arg2) {
3791
+ arg0.clearBuffer(arg1, arg2);
3792
+ },
3793
+ __wbg_clearBufferfv_2e0f1a0ea56de859: function(arg0, arg1, arg2, arg3, arg4) {
3794
+ arg0.clearBufferfv(arg1 >>> 0, arg2, getArrayF32FromWasm0(arg3, arg4));
3795
+ },
3796
+ __wbg_clearBufferiv_0360269bf6e34c54: function(arg0, arg1, arg2, arg3, arg4) {
3797
+ arg0.clearBufferiv(arg1 >>> 0, arg2, getArrayI32FromWasm0(arg3, arg4));
3798
+ },
3799
+ __wbg_clearBufferuiv_df94a395d4915377: function(arg0, arg1, arg2, arg3, arg4) {
3800
+ arg0.clearBufferuiv(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4));
3801
+ },
3802
+ __wbg_clearDepth_8b5d226aae155082: function(arg0, arg1) {
3803
+ arg0.clearDepth(arg1);
3804
+ },
3805
+ __wbg_clearDepth_ca9b22d41551b513: function(arg0, arg1) {
3806
+ arg0.clearDepth(arg1);
3807
+ },
3808
+ __wbg_clearStencil_58f2af46612bccae: function(arg0, arg1) {
3809
+ arg0.clearStencil(arg1);
3810
+ },
3811
+ __wbg_clearStencil_a66fe23df6313fc7: function(arg0, arg1) {
3812
+ arg0.clearStencil(arg1);
3813
+ },
3814
+ __wbg_clear_53d71d234e14e4c1: function(arg0, arg1) {
3815
+ arg0.clear(arg1 >>> 0);
3816
+ },
3817
+ __wbg_clear_dd06a0da4ce8e13f: function(arg0, arg1) {
3818
+ arg0.clear(arg1 >>> 0);
3819
+ },
3820
+ __wbg_clientWaitSync_cf8e49f8ba228377: function(arg0, arg1, arg2, arg3) {
3821
+ const ret = arg0.clientWaitSync(arg1, arg2 >>> 0, arg3 >>> 0);
3822
+ return ret;
3823
+ },
3824
+ __wbg_colorMask_44ebb91cad2502f2: function(arg0, arg1, arg2, arg3, arg4) {
3825
+ arg0.colorMask(arg1 !== 0, arg2 !== 0, arg3 !== 0, arg4 !== 0);
3826
+ },
3827
+ __wbg_colorMask_a4d164c2039b5731: function(arg0, arg1, arg2, arg3, arg4) {
3828
+ arg0.colorMask(arg1 !== 0, arg2 !== 0, arg3 !== 0, arg4 !== 0);
3829
+ },
3830
+ __wbg_compileShader_9bdfd792722cf704: function(arg0, arg1) {
3831
+ arg0.compileShader(arg1);
3832
+ },
3833
+ __wbg_compileShader_fc2e4b73240d4fd7: function(arg0, arg1) {
3834
+ arg0.compileShader(arg1);
3835
+ },
3836
+ __wbg_compressedTexSubImage2D_c1362291573c7268: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
3837
+ arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8, arg9);
3838
+ },
3839
+ __wbg_compressedTexSubImage2D_da01674d2975d1ae: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
3840
+ arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8);
3841
+ },
3842
+ __wbg_compressedTexSubImage2D_dd6dc580749eb5cf: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
3843
+ arg0.compressedTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8);
3844
+ },
3845
+ __wbg_compressedTexSubImage3D_04cb8b046c4321fe: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
3846
+ arg0.compressedTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10, arg11);
3847
+ },
3848
+ __wbg_compressedTexSubImage3D_af0228a80ffd5993: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
3849
+ arg0.compressedTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10);
3850
+ },
3851
+ __wbg_configure_6e4ddb3faabc6005: function() { return handleError(function (arg0, arg1) {
3852
+ arg0.configure(arg1);
3853
+ }, arguments); },
3854
+ __wbg_copyBufferSubData_cdf61f74aa6e0902: function(arg0, arg1, arg2, arg3, arg4, arg5) {
3855
+ arg0.copyBufferSubData(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
3856
+ },
3857
+ __wbg_copyBufferToBuffer_55e9540007aef863: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
3858
+ arg0.copyBufferToBuffer(arg1, arg2, arg3, arg4);
3859
+ }, arguments); },
3860
+ __wbg_copyBufferToBuffer_7adcb79ef87447dc: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
3861
+ arg0.copyBufferToBuffer(arg1, arg2, arg3, arg4, arg5);
3862
+ }, arguments); },
3863
+ __wbg_copyBufferToTexture_f0fc6311345a3dea: function() { return handleError(function (arg0, arg1, arg2, arg3) {
3864
+ arg0.copyBufferToTexture(arg1, arg2, arg3);
3865
+ }, arguments); },
3866
+ __wbg_copyTexSubImage2D_8daea651fc408645: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
3867
+ arg0.copyTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3868
+ },
3869
+ __wbg_copyTexSubImage2D_c73f91f1d7022402: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) {
3870
+ arg0.copyTexSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
3871
+ },
3872
+ __wbg_copyTexSubImage3D_bfe7a14dac9ad777: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
3873
+ arg0.copyTexSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
3874
+ },
3875
+ __wbg_copyTextureToBuffer_09ba100a04b1b001: function() { return handleError(function (arg0, arg1, arg2, arg3) {
3876
+ arg0.copyTextureToBuffer(arg1, arg2, arg3);
3877
+ }, arguments); },
3878
+ __wbg_copyTextureToTexture_66ab51b863dec546: function() { return handleError(function (arg0, arg1, arg2, arg3) {
3879
+ arg0.copyTextureToTexture(arg1, arg2, arg3);
3880
+ }, arguments); },
3881
+ __wbg_createBindGroupLayout_1dad97f44fda2929: function() { return handleError(function (arg0, arg1) {
3882
+ const ret = arg0.createBindGroupLayout(arg1);
3883
+ return ret;
3884
+ }, arguments); },
3885
+ __wbg_createBindGroup_0ee0646375643dfb: function(arg0, arg1) {
3886
+ const ret = arg0.createBindGroup(arg1);
3887
+ return ret;
3888
+ },
3889
+ __wbg_createBuffer_01568a9d930d90dd: function(arg0) {
3890
+ const ret = arg0.createBuffer();
3891
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3892
+ },
3893
+ __wbg_createBuffer_2075765bde5035d5: function(arg0) {
3894
+ const ret = arg0.createBuffer();
3895
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3896
+ },
3897
+ __wbg_createBuffer_474baee88e74f68a: function() { return handleError(function (arg0, arg1) {
3898
+ const ret = arg0.createBuffer(arg1);
3899
+ return ret;
3900
+ }, arguments); },
3901
+ __wbg_createCommandEncoder_5229e112300218b4: function(arg0, arg1) {
3902
+ const ret = arg0.createCommandEncoder(arg1);
3903
+ return ret;
3904
+ },
3905
+ __wbg_createComputePipeline_1cd8bf7e02a1a06d: function(arg0, arg1) {
3906
+ const ret = arg0.createComputePipeline(arg1);
3907
+ return ret;
3908
+ },
3909
+ __wbg_createFramebuffer_b24d2c80a8b9e7cc: function(arg0) {
3910
+ const ret = arg0.createFramebuffer();
3911
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3912
+ },
3913
+ __wbg_createFramebuffer_de0d521f546e7534: function(arg0) {
3914
+ const ret = arg0.createFramebuffer();
3915
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3916
+ },
3917
+ __wbg_createPipelineLayout_bf0deba7918ca157: function(arg0, arg1) {
3918
+ const ret = arg0.createPipelineLayout(arg1);
3919
+ return ret;
3920
+ },
3921
+ __wbg_createProgram_118becaac3a20318: function(arg0) {
3922
+ const ret = arg0.createProgram();
3923
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3924
+ },
3925
+ __wbg_createProgram_538c9777a4ac084f: function(arg0) {
3926
+ const ret = arg0.createProgram();
3927
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3928
+ },
3929
+ __wbg_createQuerySet_595e31c333f5e833: function() { return handleError(function (arg0, arg1) {
3930
+ const ret = arg0.createQuerySet(arg1);
3931
+ return ret;
3932
+ }, arguments); },
3933
+ __wbg_createQuery_047c7c524e4ac4f8: function(arg0) {
3934
+ const ret = arg0.createQuery();
3935
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3936
+ },
3937
+ __wbg_createRenderPipeline_7baf812b1e7e39e8: function() { return handleError(function (arg0, arg1) {
3938
+ const ret = arg0.createRenderPipeline(arg1);
3939
+ return ret;
3940
+ }, arguments); },
3941
+ __wbg_createRenderbuffer_71af5c0d615e9271: function(arg0) {
3942
+ const ret = arg0.createRenderbuffer();
3943
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3944
+ },
3945
+ __wbg_createRenderbuffer_9d801bf44c314f44: function(arg0) {
3946
+ const ret = arg0.createRenderbuffer();
3947
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3948
+ },
3949
+ __wbg_createSampler_5970d585f322df95: function(arg0, arg1) {
3950
+ const ret = arg0.createSampler(arg1);
3951
+ return ret;
3952
+ },
3953
+ __wbg_createSampler_70c8392d98896235: function(arg0) {
3954
+ const ret = arg0.createSampler();
3955
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3956
+ },
3957
+ __wbg_createShaderModule_744311a1dd685c14: function(arg0, arg1) {
3958
+ const ret = arg0.createShaderModule(arg1);
3959
+ return ret;
3960
+ },
3961
+ __wbg_createShader_78bc8b7e9a88e1a8: function(arg0, arg1) {
3962
+ const ret = arg0.createShader(arg1 >>> 0);
3963
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3964
+ },
3965
+ __wbg_createShader_7d139f2d50f77365: function(arg0, arg1) {
3966
+ const ret = arg0.createShader(arg1 >>> 0);
3967
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3968
+ },
3969
+ __wbg_createTexture_0ee0fa5f924f3d14: function(arg0) {
3970
+ const ret = arg0.createTexture();
3971
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3972
+ },
3973
+ __wbg_createTexture_d13f98e0d3d912f4: function(arg0) {
3974
+ const ret = arg0.createTexture();
3975
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3976
+ },
3977
+ __wbg_createTexture_f357c38256411287: function() { return handleError(function (arg0, arg1) {
3978
+ const ret = arg0.createTexture(arg1);
3979
+ return ret;
3980
+ }, arguments); },
3981
+ __wbg_createVertexArrayOES_2fa3e59eebd5f674: function(arg0) {
3982
+ const ret = arg0.createVertexArrayOES();
3983
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3984
+ },
3985
+ __wbg_createVertexArray_baf9eef7ea5a2c7a: function(arg0) {
3986
+ const ret = arg0.createVertexArray();
3987
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
3988
+ },
3989
+ __wbg_createView_e7a36ec95c4190f3: function() { return handleError(function (arg0, arg1) {
3990
+ const ret = arg0.createView(arg1);
3991
+ return ret;
3992
+ }, arguments); },
3993
+ __wbg_crypto_38df2bab126b63dc: function(arg0) {
3994
+ const ret = arg0.crypto;
3995
+ return ret;
3996
+ },
3997
+ __wbg_cullFace_62bbea3bef0e6b99: function(arg0, arg1) {
3998
+ arg0.cullFace(arg1 >>> 0);
3999
+ },
4000
+ __wbg_cullFace_f1c75ae19b07eaf3: function(arg0, arg1) {
4001
+ arg0.cullFace(arg1 >>> 0);
4002
+ },
4003
+ __wbg_deleteBuffer_08eb938e35c27967: function(arg0, arg1) {
4004
+ arg0.deleteBuffer(arg1);
4005
+ },
4006
+ __wbg_deleteBuffer_1ca3ffe668a488e7: function(arg0, arg1) {
4007
+ arg0.deleteBuffer(arg1);
4008
+ },
4009
+ __wbg_deleteFramebuffer_963cd69957209d37: function(arg0, arg1) {
4010
+ arg0.deleteFramebuffer(arg1);
4011
+ },
4012
+ __wbg_deleteFramebuffer_d1a36e889b009344: function(arg0, arg1) {
4013
+ arg0.deleteFramebuffer(arg1);
4014
+ },
4015
+ __wbg_deleteProgram_09bd45a51105b2f6: function(arg0, arg1) {
4016
+ arg0.deleteProgram(arg1);
4017
+ },
4018
+ __wbg_deleteProgram_132e191baa9fa84f: function(arg0, arg1) {
4019
+ arg0.deleteProgram(arg1);
4020
+ },
4021
+ __wbg_deleteQuery_0d1dcc4402a86ee1: function(arg0, arg1) {
4022
+ arg0.deleteQuery(arg1);
4023
+ },
4024
+ __wbg_deleteRenderbuffer_52bdbf5ab2cbe62a: function(arg0, arg1) {
4025
+ arg0.deleteRenderbuffer(arg1);
4026
+ },
4027
+ __wbg_deleteRenderbuffer_ca999f7883b777af: function(arg0, arg1) {
4028
+ arg0.deleteRenderbuffer(arg1);
4029
+ },
4030
+ __wbg_deleteSampler_0abb528566c4ab3b: function(arg0, arg1) {
4031
+ arg0.deleteSampler(arg1);
4032
+ },
4033
+ __wbg_deleteShader_3120790d36063afe: function(arg0, arg1) {
4034
+ arg0.deleteShader(arg1);
4035
+ },
4036
+ __wbg_deleteShader_993edb4beb3c4d53: function(arg0, arg1) {
4037
+ arg0.deleteShader(arg1);
4038
+ },
4039
+ __wbg_deleteSync_9b0e43580942a0f6: function(arg0, arg1) {
4040
+ arg0.deleteSync(arg1);
4041
+ },
4042
+ __wbg_deleteTexture_2b163b157ea1be24: function(arg0, arg1) {
4043
+ arg0.deleteTexture(arg1);
4044
+ },
4045
+ __wbg_deleteTexture_bdc2202d7a50dcea: function(arg0, arg1) {
4046
+ arg0.deleteTexture(arg1);
4047
+ },
4048
+ __wbg_deleteVertexArrayOES_7fa59c32cfdfa6fa: function(arg0, arg1) {
4049
+ arg0.deleteVertexArrayOES(arg1);
4050
+ },
4051
+ __wbg_deleteVertexArray_475d4e969aac1dd0: function(arg0, arg1) {
4052
+ arg0.deleteVertexArray(arg1);
4053
+ },
4054
+ __wbg_depthFunc_455cfeb8a9d2fb4c: function(arg0, arg1) {
4055
+ arg0.depthFunc(arg1 >>> 0);
4056
+ },
4057
+ __wbg_depthFunc_74a8f8acf8973c86: function(arg0, arg1) {
4058
+ arg0.depthFunc(arg1 >>> 0);
4059
+ },
4060
+ __wbg_depthMask_4bd6c73b1339d257: function(arg0, arg1) {
4061
+ arg0.depthMask(arg1 !== 0);
4062
+ },
4063
+ __wbg_depthMask_a644a67deced3257: function(arg0, arg1) {
4064
+ arg0.depthMask(arg1 !== 0);
4065
+ },
4066
+ __wbg_depthRange_38b2287ffbea14fd: function(arg0, arg1, arg2) {
4067
+ arg0.depthRange(arg1, arg2);
4068
+ },
4069
+ __wbg_depthRange_5e90d4d236280ff5: function(arg0, arg1, arg2) {
4070
+ arg0.depthRange(arg1, arg2);
4071
+ },
4072
+ __wbg_destroy_5c2c9c8b0b52b456: function(arg0) {
4073
+ arg0.destroy();
4074
+ },
4075
+ __wbg_destroy_8a3f7d0f7c49852f: function(arg0) {
4076
+ arg0.destroy();
4077
+ },
4078
+ __wbg_disableVertexAttribArray_160060fbd7e97de0: function(arg0, arg1) {
4079
+ arg0.disableVertexAttribArray(arg1 >>> 0);
4080
+ },
4081
+ __wbg_disableVertexAttribArray_c7915eb0de6dd8f1: function(arg0, arg1) {
4082
+ arg0.disableVertexAttribArray(arg1 >>> 0);
4083
+ },
4084
+ __wbg_disable_1659d1b7d50c31e7: function(arg0, arg1) {
4085
+ arg0.disable(arg1 >>> 0);
4086
+ },
4087
+ __wbg_disable_40c3975167c1ee07: function(arg0, arg1) {
4088
+ arg0.disable(arg1 >>> 0);
4089
+ },
4090
+ __wbg_dispatchWorkgroups_727fa35f9c69d73c: function(arg0, arg1, arg2, arg3) {
4091
+ arg0.dispatchWorkgroups(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0);
4092
+ },
4093
+ __wbg_document_179650d6cb13c263: function(arg0) {
4094
+ const ret = arg0.document;
4095
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4096
+ },
4097
+ __wbg_drawArraysInstancedANGLE_d58dbd2d38fdebaa: function(arg0, arg1, arg2, arg3, arg4) {
4098
+ arg0.drawArraysInstancedANGLE(arg1 >>> 0, arg2, arg3, arg4);
4099
+ },
4100
+ __wbg_drawArraysInstanced_51b161548a3f10c4: function(arg0, arg1, arg2, arg3, arg4) {
4101
+ arg0.drawArraysInstanced(arg1 >>> 0, arg2, arg3, arg4);
4102
+ },
4103
+ __wbg_drawArrays_676becae0149ed65: function(arg0, arg1, arg2, arg3) {
4104
+ arg0.drawArrays(arg1 >>> 0, arg2, arg3);
4105
+ },
4106
+ __wbg_drawArrays_b0c59a6e158122f2: function(arg0, arg1, arg2, arg3) {
4107
+ arg0.drawArrays(arg1 >>> 0, arg2, arg3);
4108
+ },
4109
+ __wbg_drawBuffersWEBGL_c9b47f7f207125cf: function(arg0, arg1) {
4110
+ arg0.drawBuffersWEBGL(arg1);
4111
+ },
4112
+ __wbg_drawBuffers_1c1ec9b292442a2a: function(arg0, arg1) {
4113
+ arg0.drawBuffers(arg1);
4114
+ },
4115
+ __wbg_drawElementsInstancedANGLE_9b58c4013373b180: function(arg0, arg1, arg2, arg3, arg4, arg5) {
4116
+ arg0.drawElementsInstancedANGLE(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
4117
+ },
4118
+ __wbg_drawElementsInstanced_c7f96ea02e6d5326: function(arg0, arg1, arg2, arg3, arg4, arg5) {
4119
+ arg0.drawElementsInstanced(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
4120
+ },
4121
+ __wbg_drawIndexed_2ab8259f769f352d: function(arg0, arg1, arg2, arg3, arg4, arg5) {
4122
+ arg0.drawIndexed(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5 >>> 0);
4123
+ },
4124
+ __wbg_draw_b93abd56938fa3b6: function(arg0, arg1, arg2, arg3, arg4) {
4125
+ arg0.draw(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
4126
+ },
4127
+ __wbg_enableVertexAttribArray_4c08219124740f14: function(arg0, arg1) {
4128
+ arg0.enableVertexAttribArray(arg1 >>> 0);
4129
+ },
4130
+ __wbg_enableVertexAttribArray_7470ba2dcf2606e3: function(arg0, arg1) {
4131
+ arg0.enableVertexAttribArray(arg1 >>> 0);
4132
+ },
4133
+ __wbg_enable_28bbeed576131d1f: function(arg0, arg1) {
4134
+ arg0.enable(arg1 >>> 0);
4135
+ },
4136
+ __wbg_enable_611804c0ac1504ce: function(arg0, arg1) {
4137
+ arg0.enable(arg1 >>> 0);
4138
+ },
4139
+ __wbg_endQuery_a50f7fc49cfe56e9: function(arg0, arg1) {
4140
+ arg0.endQuery(arg1 >>> 0);
4141
+ },
4142
+ __wbg_end_2398df10208cf1ee: function(arg0) {
4143
+ arg0.end();
4144
+ },
4145
+ __wbg_end_2fdce848e1c526bc: function(arg0) {
4146
+ arg0.end();
4147
+ },
4148
+ __wbg_error_96e899f14d8344a2: function(arg0, arg1) {
4149
+ console.error(getStringFromWasm0(arg0, arg1));
4150
+ },
4151
+ __wbg_features_139b41635cafee99: function(arg0) {
4152
+ const ret = arg0.features;
4153
+ return ret;
4154
+ },
4155
+ __wbg_features_3fa0fe4fc37163a7: function(arg0) {
4156
+ const ret = arg0.features;
4157
+ return ret;
4158
+ },
4159
+ __wbg_fenceSync_fe2cdba4a0d73679: function(arg0, arg1, arg2) {
4160
+ const ret = arg0.fenceSync(arg1 >>> 0, arg2 >>> 0);
4161
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4162
+ },
4163
+ __wbg_fetch_58167e2c1ef32e0a: function(arg0, arg1, arg2) {
4164
+ const ret = arg0.fetch(getStringFromWasm0(arg1, arg2));
4165
+ return ret;
4166
+ },
4167
+ __wbg_finish_7370ad1c0e62b448: function(arg0) {
4168
+ const ret = arg0.finish();
4169
+ return ret;
4170
+ },
4171
+ __wbg_finish_797b32d15bab2338: function(arg0, arg1) {
4172
+ const ret = arg0.finish(arg1);
4173
+ return ret;
4174
+ },
4175
+ __wbg_flush_db77b4a63d6b337d: function(arg0) {
4176
+ arg0.flush();
4177
+ },
4178
+ __wbg_flush_e03c08da6863b5ab: function(arg0) {
4179
+ arg0.flush();
4180
+ },
4181
+ __wbg_framebufferRenderbuffer_4404cf9f9cb76937: function(arg0, arg1, arg2, arg3, arg4) {
4182
+ arg0.framebufferRenderbuffer(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4);
4183
+ },
4184
+ __wbg_framebufferRenderbuffer_ba8bd5e008ee87eb: function(arg0, arg1, arg2, arg3, arg4) {
4185
+ arg0.framebufferRenderbuffer(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4);
4186
+ },
4187
+ __wbg_framebufferTexture2D_3c2abd606fc53f31: function(arg0, arg1, arg2, arg3, arg4, arg5) {
4188
+ arg0.framebufferTexture2D(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5);
4189
+ },
4190
+ __wbg_framebufferTexture2D_e1fb64212fcda219: function(arg0, arg1, arg2, arg3, arg4, arg5) {
4191
+ arg0.framebufferTexture2D(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4, arg5);
4192
+ },
4193
+ __wbg_framebufferTextureLayer_f2d9db097bfbb863: function(arg0, arg1, arg2, arg3, arg4, arg5) {
4194
+ arg0.framebufferTextureLayer(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5);
4195
+ },
4196
+ __wbg_framebufferTextureMultiviewOVR_28d492b9dc484220: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
4197
+ arg0.framebufferTextureMultiviewOVR(arg1 >>> 0, arg2 >>> 0, arg3, arg4, arg5, arg6);
4198
+ },
4199
+ __wbg_frontFace_29ef7151de8b5ed9: function(arg0, arg1) {
4200
+ arg0.frontFace(arg1 >>> 0);
4201
+ },
4202
+ __wbg_frontFace_fc6d98dafa42de87: function(arg0, arg1) {
4203
+ arg0.frontFace(arg1 >>> 0);
4204
+ },
4205
+ __wbg_getBindGroupLayout_0b3b7dd9f45e8e19: function(arg0, arg1) {
4206
+ const ret = arg0.getBindGroupLayout(arg1 >>> 0);
4207
+ return ret;
4208
+ },
4209
+ __wbg_getBindGroupLayout_9fc232d022bf8cca: function(arg0, arg1) {
4210
+ const ret = arg0.getBindGroupLayout(arg1 >>> 0);
4211
+ return ret;
4212
+ },
4213
+ __wbg_getBufferSubData_11018928c908ac2c: function(arg0, arg1, arg2, arg3) {
4214
+ arg0.getBufferSubData(arg1 >>> 0, arg2, arg3);
4215
+ },
4216
+ __wbg_getContext_7476e39fa008047e: function() { return handleError(function (arg0, arg1, arg2, arg3) {
4217
+ const ret = arg0.getContext(getStringFromWasm0(arg1, arg2), arg3);
4218
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4219
+ }, arguments); },
4220
+ __wbg_getContext_ca12bb65aab778a4: function() { return handleError(function (arg0, arg1, arg2, arg3) {
4221
+ const ret = arg0.getContext(getStringFromWasm0(arg1, arg2), arg3);
4222
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4223
+ }, arguments); },
4224
+ __wbg_getContext_e79ddf6a9cb3cc76: function() { return handleError(function (arg0, arg1, arg2) {
4225
+ const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
4226
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4227
+ }, arguments); },
4228
+ __wbg_getContext_fd298c901058eb31: function() { return handleError(function (arg0, arg1, arg2) {
4229
+ const ret = arg0.getContext(getStringFromWasm0(arg1, arg2));
4230
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4231
+ }, arguments); },
4232
+ __wbg_getCurrentTexture_628ddb7c08d25190: function() { return handleError(function (arg0) {
4233
+ const ret = arg0.getCurrentTexture();
4234
+ return ret;
4235
+ }, arguments); },
4236
+ __wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
4237
+ const ret = arg0.getDate();
4238
+ return ret;
4239
+ },
4240
+ __wbg_getDay_aa318cce5da74c49: function(arg0) {
4241
+ const ret = arg0.getDay();
4242
+ return ret;
4243
+ },
4244
+ __wbg_getExtension_101c7e41de3e4d90: function() { return handleError(function (arg0, arg1, arg2) {
4245
+ const ret = arg0.getExtension(getStringFromWasm0(arg1, arg2));
4246
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4247
+ }, arguments); },
4248
+ __wbg_getFullYear_6af8b229792ae254: function(arg0) {
4249
+ const ret = arg0.getFullYear();
4250
+ return ret;
4251
+ },
4252
+ __wbg_getHours_9f6561095682ce51: function(arg0) {
4253
+ const ret = arg0.getHours();
4254
+ return ret;
4255
+ },
4256
+ __wbg_getIndexedParameter_6d7a5bcccaa0f3e2: function() { return handleError(function (arg0, arg1, arg2) {
4257
+ const ret = arg0.getIndexedParameter(arg1 >>> 0, arg2 >>> 0);
4258
+ return ret;
4259
+ }, arguments); },
4260
+ __wbg_getMappedRange_9f13d158ba3946fd: function() { return handleError(function (arg0, arg1, arg2) {
4261
+ const ret = arg0.getMappedRange(arg1, arg2);
4262
+ return ret;
4263
+ }, arguments); },
4264
+ __wbg_getMinutes_b0d5cd90bf9b8f22: function(arg0) {
4265
+ const ret = arg0.getMinutes();
4266
+ return ret;
4267
+ },
4268
+ __wbg_getMonth_fffe29d654d5eb69: function(arg0) {
4269
+ const ret = arg0.getMonth();
4270
+ return ret;
4271
+ },
4272
+ __wbg_getParameter_039a5899307fab55: function() { return handleError(function (arg0, arg1) {
4273
+ const ret = arg0.getParameter(arg1 >>> 0);
4274
+ return ret;
4275
+ }, arguments); },
4276
+ __wbg_getParameter_d39f59581389af1b: function() { return handleError(function (arg0, arg1) {
4277
+ const ret = arg0.getParameter(arg1 >>> 0);
4278
+ return ret;
4279
+ }, arguments); },
4280
+ __wbg_getPreferredCanvasFormat_a2b6306e828c2f60: function(arg0) {
4281
+ const ret = arg0.getPreferredCanvasFormat();
4282
+ return (__wbindgen_enum_GpuTextureFormat.indexOf(ret) + 1 || 96) - 1;
4283
+ },
4284
+ __wbg_getProgramInfoLog_c4762e0513468a26: function(arg0, arg1, arg2) {
4285
+ const ret = arg1.getProgramInfoLog(arg2);
4286
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4287
+ var len1 = WASM_VECTOR_LEN;
4288
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4289
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4290
+ },
4291
+ __wbg_getProgramInfoLog_d1ce570463a68779: function(arg0, arg1, arg2) {
4292
+ const ret = arg1.getProgramInfoLog(arg2);
4293
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4294
+ var len1 = WASM_VECTOR_LEN;
4295
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4296
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4297
+ },
4298
+ __wbg_getProgramParameter_b9995b56c258ac86: function(arg0, arg1, arg2) {
4299
+ const ret = arg0.getProgramParameter(arg1, arg2 >>> 0);
4300
+ return ret;
4301
+ },
4302
+ __wbg_getProgramParameter_c8d1154fbb3c0890: function(arg0, arg1, arg2) {
4303
+ const ret = arg0.getProgramParameter(arg1, arg2 >>> 0);
4304
+ return ret;
4305
+ },
4306
+ __wbg_getQueryParameter_919125495ccb17ca: function(arg0, arg1, arg2) {
4307
+ const ret = arg0.getQueryParameter(arg1, arg2 >>> 0);
4308
+ return ret;
4309
+ },
4310
+ __wbg_getRandomValues_c44a50d8cfdaebeb: function() { return handleError(function (arg0, arg1) {
4311
+ arg0.getRandomValues(arg1);
4312
+ }, arguments); },
4313
+ __wbg_getShaderInfoLog_5cee2add982c7165: function(arg0, arg1, arg2) {
4314
+ const ret = arg1.getShaderInfoLog(arg2);
4315
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4316
+ var len1 = WASM_VECTOR_LEN;
4317
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4318
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4319
+ },
4320
+ __wbg_getShaderInfoLog_bc236afe696c1283: function(arg0, arg1, arg2) {
4321
+ const ret = arg1.getShaderInfoLog(arg2);
4322
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4323
+ var len1 = WASM_VECTOR_LEN;
4324
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4325
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4326
+ },
4327
+ __wbg_getShaderParameter_3394e75dcb97f380: function(arg0, arg1, arg2) {
4328
+ const ret = arg0.getShaderParameter(arg1, arg2 >>> 0);
4329
+ return ret;
4330
+ },
4331
+ __wbg_getShaderParameter_cbcc0995e8e16214: function(arg0, arg1, arg2) {
4332
+ const ret = arg0.getShaderParameter(arg1, arg2 >>> 0);
4333
+ return ret;
4334
+ },
4335
+ __wbg_getSupportedExtensions_2a7458ec45e82560: function(arg0) {
4336
+ const ret = arg0.getSupportedExtensions();
4337
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4338
+ },
4339
+ __wbg_getSupportedProfiles_90a4f330938d0241: function(arg0) {
4340
+ const ret = arg0.getSupportedProfiles();
4341
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4342
+ },
4343
+ __wbg_getSyncParameter_d8f6c145657a3550: function(arg0, arg1, arg2) {
4344
+ const ret = arg0.getSyncParameter(arg1, arg2 >>> 0);
4345
+ return ret;
4346
+ },
4347
+ __wbg_getUniformBlockIndex_cfee6ff6d323c784: function(arg0, arg1, arg2, arg3) {
4348
+ const ret = arg0.getUniformBlockIndex(arg1, getStringFromWasm0(arg2, arg3));
4349
+ return ret;
4350
+ },
4351
+ __wbg_getUniformLocation_24ef46cdda2148ab: function(arg0, arg1, arg2, arg3) {
4352
+ const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));
4353
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4354
+ },
4355
+ __wbg_getUniformLocation_788a34295dd6fabe: function(arg0, arg1, arg2, arg3) {
4356
+ const ret = arg0.getUniformLocation(arg1, getStringFromWasm0(arg2, arg3));
4357
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4358
+ },
4359
+ __wbg_get_18e0163e38e5048d: function() { return handleError(function (arg0, arg1, arg2, arg3) {
4360
+ const ret = arg1.get(getStringFromWasm0(arg2, arg3));
4361
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4362
+ var len1 = WASM_VECTOR_LEN;
4363
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4364
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4365
+ }, arguments); },
4366
+ __wbg_get_b2053e9bfdf3ca8e: function(arg0, arg1) {
4367
+ const ret = arg0[arg1 >>> 0];
4368
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4369
+ },
4370
+ __wbg_get_unchecked_6e0ad6d2a41b06f6: function(arg0, arg1) {
4371
+ const ret = arg0[arg1 >>> 0];
4372
+ return ret;
4373
+ },
4374
+ __wbg_gpu_ac6dc8fb638a26c3: function(arg0) {
4375
+ const ret = arg0.gpu;
4376
+ return ret;
4377
+ },
4378
+ __wbg_has_ffcf0ac839d1b8fb: function(arg0, arg1, arg2) {
4379
+ const ret = arg0.has(getStringFromWasm0(arg1, arg2));
4380
+ return ret;
4381
+ },
4382
+ __wbg_headers_cf9c80f30e2a4eff: function(arg0) {
4383
+ const ret = arg0.headers;
4384
+ return ret;
4385
+ },
4386
+ __wbg_height_6eec812c213259a1: function(arg0) {
4387
+ const ret = arg0.height;
4388
+ return ret;
4389
+ },
4390
+ __wbg_includes_78c9a3115b08eddc: function(arg0, arg1, arg2) {
4391
+ const ret = arg0.includes(arg1, arg2);
4392
+ return ret;
4393
+ },
4394
+ __wbg_instanceof_GpuAdapter_fb230cdccb184887: function(arg0) {
4395
+ let result;
4396
+ try {
4397
+ result = arg0 instanceof GPUAdapter;
4398
+ } catch (_) {
4399
+ result = false;
4400
+ }
4401
+ const ret = result;
4402
+ return ret;
4403
+ },
4404
+ __wbg_instanceof_GpuCanvasContext_48ec5330c4425d84: function(arg0) {
4405
+ let result;
4406
+ try {
4407
+ result = arg0 instanceof GPUCanvasContext;
4408
+ } catch (_) {
4409
+ result = false;
4410
+ }
4411
+ const ret = result;
4412
+ return ret;
4413
+ },
4414
+ __wbg_instanceof_GpuOutOfMemoryError_7b1554dded417c4f: function(arg0) {
4415
+ let result;
4416
+ try {
4417
+ result = arg0 instanceof GPUOutOfMemoryError;
4418
+ } catch (_) {
4419
+ result = false;
4420
+ }
4421
+ const ret = result;
4422
+ return ret;
4423
+ },
4424
+ __wbg_instanceof_GpuValidationError_124458c5a6bb3b58: function(arg0) {
4425
+ let result;
4426
+ try {
4427
+ result = arg0 instanceof GPUValidationError;
4428
+ } catch (_) {
4429
+ result = false;
4430
+ }
4431
+ const ret = result;
4432
+ return ret;
4433
+ },
4434
+ __wbg_instanceof_HtmlCanvasElement_ed02ed9136056019: function(arg0) {
4435
+ let result;
4436
+ try {
4437
+ result = arg0 instanceof HTMLCanvasElement;
4438
+ } catch (_) {
4439
+ result = false;
4440
+ }
4441
+ const ret = result;
4442
+ return ret;
4443
+ },
4444
+ __wbg_instanceof_Object_33f20e6f12439f3e: function(arg0) {
4445
+ let result;
4446
+ try {
4447
+ result = arg0 instanceof Object;
4448
+ } catch (_) {
4449
+ result = false;
4450
+ }
4451
+ const ret = result;
4452
+ return ret;
4453
+ },
4454
+ __wbg_instanceof_Response_c8b64b2256f01bec: function(arg0) {
4455
+ let result;
4456
+ try {
4457
+ result = arg0 instanceof Response;
4458
+ } catch (_) {
4459
+ result = false;
4460
+ }
4461
+ const ret = result;
4462
+ return ret;
4463
+ },
4464
+ __wbg_instanceof_WebGl2RenderingContext_90225152e4e3c799: function(arg0) {
4465
+ let result;
4466
+ try {
4467
+ result = arg0 instanceof WebGL2RenderingContext;
4468
+ } catch (_) {
4469
+ result = false;
4470
+ }
4471
+ const ret = result;
4472
+ return ret;
4473
+ },
4474
+ __wbg_instanceof_Window_05ba1ee4f6781663: function(arg0) {
4475
+ let result;
4476
+ try {
4477
+ result = arg0 instanceof Window;
4478
+ } catch (_) {
4479
+ result = false;
4480
+ }
4481
+ const ret = result;
4482
+ return ret;
4483
+ },
4484
+ __wbg_invalidateFramebuffer_343bbfb15e6835fd: function() { return handleError(function (arg0, arg1, arg2) {
4485
+ arg0.invalidateFramebuffer(arg1 >>> 0, arg2);
4486
+ }, arguments); },
4487
+ __wbg_is_7b9d0b289033c7de: function(arg0, arg1) {
4488
+ const ret = Object.is(arg0, arg1);
4489
+ return ret;
4490
+ },
4491
+ __wbg_label_84abde6506fa15b7: function(arg0, arg1) {
4492
+ const ret = arg1.label;
4493
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4494
+ const len1 = WASM_VECTOR_LEN;
4495
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4496
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4497
+ },
4498
+ __wbg_length_1f0964f4a5e2c6d8: function(arg0) {
4499
+ const ret = arg0.length;
4500
+ return ret;
4501
+ },
4502
+ __wbg_length_370319915dc99107: function(arg0) {
4503
+ const ret = arg0.length;
4504
+ return ret;
4505
+ },
4506
+ __wbg_limits_a80585efb442d985: function(arg0) {
4507
+ const ret = arg0.limits;
4508
+ return ret;
4509
+ },
4510
+ __wbg_limits_d4ef440224084d65: function(arg0) {
4511
+ const ret = arg0.limits;
4512
+ return ret;
4513
+ },
4514
+ __wbg_linkProgram_4e047fb3197a0348: function(arg0, arg1) {
4515
+ arg0.linkProgram(arg1);
4516
+ },
4517
+ __wbg_linkProgram_d7c71c539c8c6a43: function(arg0, arg1) {
4518
+ arg0.linkProgram(arg1);
4519
+ },
4520
+ __wbg_mapAsync_3546b4b874e14738: function(arg0, arg1, arg2, arg3) {
4521
+ const ret = arg0.mapAsync(arg1 >>> 0, arg2, arg3);
4522
+ return ret;
4523
+ },
4524
+ __wbg_maxBindGroups_2fac2855adae76bb: function(arg0) {
4525
+ const ret = arg0.maxBindGroups;
4526
+ return ret;
4527
+ },
4528
+ __wbg_maxBindingsPerBindGroup_7b8b526a1900701d: function(arg0) {
4529
+ const ret = arg0.maxBindingsPerBindGroup;
4530
+ return ret;
4531
+ },
4532
+ __wbg_maxBufferSize_475dcdac4810587e: function(arg0) {
4533
+ const ret = arg0.maxBufferSize;
4534
+ return ret;
4535
+ },
4536
+ __wbg_maxColorAttachmentBytesPerSample_5a04a2d5a9e122bb: function(arg0) {
4537
+ const ret = arg0.maxColorAttachmentBytesPerSample;
4538
+ return ret;
4539
+ },
4540
+ __wbg_maxColorAttachments_2a487bb283cf8f08: function(arg0) {
4541
+ const ret = arg0.maxColorAttachments;
4542
+ return ret;
4543
+ },
4544
+ __wbg_maxComputeInvocationsPerWorkgroup_72908780df74614a: function(arg0) {
4545
+ const ret = arg0.maxComputeInvocationsPerWorkgroup;
4546
+ return ret;
4547
+ },
4548
+ __wbg_maxComputeWorkgroupSizeX_92eeefd082aefd07: function(arg0) {
4549
+ const ret = arg0.maxComputeWorkgroupSizeX;
4550
+ return ret;
4551
+ },
4552
+ __wbg_maxComputeWorkgroupSizeY_54fecee60bfa33ae: function(arg0) {
4553
+ const ret = arg0.maxComputeWorkgroupSizeY;
4554
+ return ret;
4555
+ },
4556
+ __wbg_maxComputeWorkgroupSizeZ_868f559f4eebf95f: function(arg0) {
4557
+ const ret = arg0.maxComputeWorkgroupSizeZ;
4558
+ return ret;
4559
+ },
4560
+ __wbg_maxComputeWorkgroupStorageSize_b4fd07bd827bde34: function(arg0) {
4561
+ const ret = arg0.maxComputeWorkgroupStorageSize;
4562
+ return ret;
4563
+ },
4564
+ __wbg_maxComputeWorkgroupsPerDimension_2d88e3f8e1f984fc: function(arg0) {
4565
+ const ret = arg0.maxComputeWorkgroupsPerDimension;
4566
+ return ret;
4567
+ },
4568
+ __wbg_maxDynamicStorageBuffersPerPipelineLayout_d6f0075161a2ec8e: function(arg0) {
4569
+ const ret = arg0.maxDynamicStorageBuffersPerPipelineLayout;
4570
+ return ret;
4571
+ },
4572
+ __wbg_maxDynamicUniformBuffersPerPipelineLayout_4fc01fff17019d2b: function(arg0) {
4573
+ const ret = arg0.maxDynamicUniformBuffersPerPipelineLayout;
4574
+ return ret;
4575
+ },
4576
+ __wbg_maxSampledTexturesPerShaderStage_224452301226d09a: function(arg0) {
4577
+ const ret = arg0.maxSampledTexturesPerShaderStage;
4578
+ return ret;
4579
+ },
4580
+ __wbg_maxSamplersPerShaderStage_34936f99dde7ae66: function(arg0) {
4581
+ const ret = arg0.maxSamplersPerShaderStage;
4582
+ return ret;
4583
+ },
4584
+ __wbg_maxStorageBufferBindingSize_9582c7cfe68faac0: function(arg0) {
4585
+ const ret = arg0.maxStorageBufferBindingSize;
4586
+ return ret;
4587
+ },
4588
+ __wbg_maxStorageBuffersPerShaderStage_6403069e851040db: function(arg0) {
4589
+ const ret = arg0.maxStorageBuffersPerShaderStage;
4590
+ return ret;
4591
+ },
4592
+ __wbg_maxStorageTexturesPerShaderStage_e44d7d6ed85de663: function(arg0) {
4593
+ const ret = arg0.maxStorageTexturesPerShaderStage;
4594
+ return ret;
4595
+ },
4596
+ __wbg_maxTextureArrayLayers_0f2fe636cc0fa44f: function(arg0) {
4597
+ const ret = arg0.maxTextureArrayLayers;
4598
+ return ret;
4599
+ },
4600
+ __wbg_maxTextureDimension1D_501e1e21119c564f: function(arg0) {
4601
+ const ret = arg0.maxTextureDimension1D;
4602
+ return ret;
4603
+ },
4604
+ __wbg_maxTextureDimension2D_ac594a0008180ab6: function(arg0) {
4605
+ const ret = arg0.maxTextureDimension2D;
4606
+ return ret;
4607
+ },
4608
+ __wbg_maxTextureDimension3D_8e5638a46d5786b0: function(arg0) {
4609
+ const ret = arg0.maxTextureDimension3D;
4610
+ return ret;
4611
+ },
4612
+ __wbg_maxUniformBufferBindingSize_a4c4feca62b81571: function(arg0) {
4613
+ const ret = arg0.maxUniformBufferBindingSize;
4614
+ return ret;
4615
+ },
4616
+ __wbg_maxUniformBuffersPerShaderStage_505f14dd3f814492: function(arg0) {
4617
+ const ret = arg0.maxUniformBuffersPerShaderStage;
4618
+ return ret;
4619
+ },
4620
+ __wbg_maxVertexAttributes_c4f4881b2d20616b: function(arg0) {
4621
+ const ret = arg0.maxVertexAttributes;
4622
+ return ret;
4623
+ },
4624
+ __wbg_maxVertexBufferArrayStride_da0782b779fc1a38: function(arg0) {
4625
+ const ret = arg0.maxVertexBufferArrayStride;
4626
+ return ret;
4627
+ },
4628
+ __wbg_maxVertexBuffers_90e848bae7f01af3: function(arg0) {
4629
+ const ret = arg0.maxVertexBuffers;
4630
+ return ret;
4631
+ },
4632
+ __wbg_message_bd5755a324c3b999: function(arg0, arg1) {
4633
+ const ret = arg1.message;
4634
+ const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
4635
+ const len1 = WASM_VECTOR_LEN;
4636
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
4637
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
4638
+ },
4639
+ __wbg_minStorageBufferOffsetAlignment_58fcc139ce14bbb9: function(arg0) {
4640
+ const ret = arg0.minStorageBufferOffsetAlignment;
4641
+ return ret;
4642
+ },
4643
+ __wbg_minUniformBufferOffsetAlignment_33ca7570ff80f825: function(arg0) {
4644
+ const ret = arg0.minUniformBufferOffsetAlignment;
4645
+ return ret;
4646
+ },
4647
+ __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
4648
+ const ret = arg0.msCrypto;
4649
+ return ret;
4650
+ },
4651
+ __wbg_navigator_51379c10a84aeec9: function(arg0) {
4652
+ const ret = arg0.navigator;
4653
+ return ret;
4654
+ },
4655
+ __wbg_navigator_99621db14b3f1099: function(arg0) {
4656
+ const ret = arg0.navigator;
4657
+ return ret;
4658
+ },
4659
+ __wbg_new_0_3da9e97f24fc69be: function() {
4660
+ const ret = new Date();
4661
+ return ret;
4662
+ },
4663
+ __wbg_new_32b398fb48b6d94a: function() {
4664
+ const ret = new Array();
4665
+ return ret;
4666
+ },
4667
+ __wbg_new_cd45aabdf6073e84: function(arg0) {
4668
+ const ret = new Uint8Array(arg0);
4669
+ return ret;
4670
+ },
4671
+ __wbg_new_da52cf8fe3429cb2: function() {
4672
+ const ret = new Object();
4673
+ return ret;
4674
+ },
4675
+ __wbg_new_from_slice_77cdfb7977362f3c: function(arg0, arg1) {
4676
+ const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
4677
+ return ret;
4678
+ },
4679
+ __wbg_new_typed_1824d93f294193e5: function(arg0, arg1) {
4680
+ try {
4681
+ var state0 = {a: arg0, b: arg1};
4682
+ var cb0 = (arg0, arg1) => {
4683
+ const a = state0.a;
4684
+ state0.a = 0;
4685
+ try {
4686
+ return wasm_bindgen__convert__closures_____invoke__h1149b643047c36f1(a, state0.b, arg0, arg1);
4687
+ } finally {
4688
+ state0.a = a;
4689
+ }
4690
+ };
4691
+ const ret = new Promise(cb0);
4692
+ return ret;
4693
+ } finally {
4694
+ state0.a = 0;
4695
+ }
4696
+ },
4697
+ __wbg_new_with_byte_offset_and_length_54c7724ee3ec7d82: function(arg0, arg1, arg2) {
4698
+ const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
4699
+ return ret;
4700
+ },
4701
+ __wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
4702
+ const ret = new Uint8Array(arg0 >>> 0);
4703
+ return ret;
4704
+ },
4705
+ __wbg_node_84ea875411254db1: function(arg0) {
4706
+ const ret = arg0.node;
4707
+ return ret;
4708
+ },
4709
+ __wbg_now_86c0d4ba3fa605b8: function() {
4710
+ const ret = Date.now();
4711
+ return ret;
4712
+ },
4713
+ __wbg_of_85f52f8b6491a7ca: function(arg0) {
4714
+ const ret = Array.of(arg0);
4715
+ return ret;
4716
+ },
4717
+ __wbg_ok_acc5e3fb89668864: function(arg0) {
4718
+ const ret = arg0.ok;
4719
+ return ret;
4720
+ },
4721
+ __wbg_onSubmittedWorkDone_5c020973b11ab15f: function(arg0) {
4722
+ const ret = arg0.onSubmittedWorkDone();
4723
+ return ret;
4724
+ },
4725
+ __wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
4726
+ const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
4727
+ return ret;
4728
+ }, arguments); },
4729
+ __wbg_pixelStorei_2a93b18efde9acf8: function(arg0, arg1, arg2) {
4730
+ arg0.pixelStorei(arg1 >>> 0, arg2);
4731
+ },
4732
+ __wbg_pixelStorei_c844cd0db4f1fde6: function(arg0, arg1, arg2) {
4733
+ arg0.pixelStorei(arg1 >>> 0, arg2);
4734
+ },
4735
+ __wbg_polygonOffset_4eb460adf41db6cd: function(arg0, arg1, arg2) {
4736
+ arg0.polygonOffset(arg1, arg2);
4737
+ },
4738
+ __wbg_polygonOffset_eccb68e40a18f861: function(arg0, arg1, arg2) {
4739
+ arg0.polygonOffset(arg1, arg2);
4740
+ },
4741
+ __wbg_popErrorScope_20ec53d3d70b2173: function(arg0) {
4742
+ const ret = arg0.popErrorScope();
4743
+ return ret;
4744
+ },
4745
+ __wbg_process_44c7a14e11e9f69e: function(arg0) {
4746
+ const ret = arg0.process;
4747
+ return ret;
4748
+ },
4749
+ __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
4750
+ Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
4751
+ },
4752
+ __wbg_pushErrorScope_d3e17b69be8837df: function(arg0, arg1) {
4753
+ arg0.pushErrorScope(__wbindgen_enum_GpuErrorFilter[arg1]);
4754
+ },
4755
+ __wbg_push_d2ae3af0c1217ae6: function(arg0, arg1) {
4756
+ const ret = arg0.push(arg1);
4757
+ return ret;
4758
+ },
4759
+ __wbg_queryCounterEXT_b74a4567ddfeecf0: function(arg0, arg1, arg2) {
4760
+ arg0.queryCounterEXT(arg1, arg2 >>> 0);
4761
+ },
4762
+ __wbg_querySelectorAll_7e98cbe256deaadd: function() { return handleError(function (arg0, arg1, arg2) {
4763
+ const ret = arg0.querySelectorAll(getStringFromWasm0(arg1, arg2));
4764
+ return ret;
4765
+ }, arguments); },
4766
+ __wbg_querySelector_fd7d157ebe17cd16: function() { return handleError(function (arg0, arg1, arg2) {
4767
+ const ret = arg0.querySelector(getStringFromWasm0(arg1, arg2));
4768
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
4769
+ }, arguments); },
4770
+ __wbg_queueMicrotask_0ab5b2d2393e99b9: function(arg0) {
4771
+ const ret = arg0.queueMicrotask;
4772
+ return ret;
4773
+ },
4774
+ __wbg_queueMicrotask_6a09b7bc46549209: function(arg0) {
4775
+ queueMicrotask(arg0);
4776
+ },
4777
+ __wbg_queue_8cb065d04b06cb13: function(arg0) {
4778
+ const ret = arg0.queue;
4779
+ return ret;
4780
+ },
4781
+ __wbg_randomFillSync_6c25eac9869eb53c: function() { return handleError(function (arg0, arg1) {
4782
+ arg0.randomFillSync(arg1);
4783
+ }, arguments); },
4784
+ __wbg_readBuffer_4271437a70aae481: function(arg0, arg1) {
4785
+ arg0.readBuffer(arg1 >>> 0);
4786
+ },
4787
+ __wbg_readPixels_5f013a7d85b23800: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
4788
+ arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
4789
+ }, arguments); },
4790
+ __wbg_readPixels_82c9dee754d58176: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
4791
+ arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
4792
+ }, arguments); },
4793
+ __wbg_readPixels_c7861e25836bf57b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
4794
+ arg0.readPixels(arg1, arg2, arg3, arg4, arg5 >>> 0, arg6 >>> 0, arg7);
4795
+ }, arguments); },
4796
+ __wbg_renderbufferStorageMultisample_5c6e5d20c0eaa6ba: function(arg0, arg1, arg2, arg3, arg4, arg5) {
4797
+ arg0.renderbufferStorageMultisample(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
4798
+ },
4799
+ __wbg_renderbufferStorage_0a8de92542893819: function(arg0, arg1, arg2, arg3, arg4) {
4800
+ arg0.renderbufferStorage(arg1 >>> 0, arg2 >>> 0, arg3, arg4);
4801
+ },
4802
+ __wbg_renderbufferStorage_ab5f745ff8efce3d: function(arg0, arg1, arg2, arg3, arg4) {
4803
+ arg0.renderbufferStorage(arg1 >>> 0, arg2 >>> 0, arg3, arg4);
4804
+ },
4805
+ __wbg_requestAdapter_4814cb479d2dcf15: function(arg0, arg1) {
4806
+ const ret = arg0.requestAdapter(arg1);
4807
+ return ret;
4808
+ },
4809
+ __wbg_requestDevice_1b8f321791aa8b00: function(arg0, arg1) {
4810
+ const ret = arg0.requestDevice(arg1);
4811
+ return ret;
4812
+ },
4813
+ __wbg_require_b4edbdcf3e2a1ef0: function() { return handleError(function () {
4814
+ const ret = module.require;
4815
+ return ret;
4816
+ }, arguments); },
4817
+ __wbg_resolve_2191a4dfe481c25b: function(arg0) {
4818
+ const ret = Promise.resolve(arg0);
4819
+ return ret;
4820
+ },
4821
+ __wbg_samplerParameterf_0b3308eeb1faa3a1: function(arg0, arg1, arg2, arg3) {
4822
+ arg0.samplerParameterf(arg1, arg2 >>> 0, arg3);
4823
+ },
4824
+ __wbg_samplerParameteri_7b1b4091de49aabb: function(arg0, arg1, arg2, arg3) {
4825
+ arg0.samplerParameteri(arg1, arg2 >>> 0, arg3);
4826
+ },
4827
+ __wbg_scenecanvas_new: function(arg0) {
4828
+ const ret = SceneCanvas.__wrap(arg0);
4829
+ return ret;
4830
+ },
4831
+ __wbg_scissor_105e756596bc35df: function(arg0, arg1, arg2, arg3, arg4) {
4832
+ arg0.scissor(arg1, arg2, arg3, arg4);
4833
+ },
4834
+ __wbg_scissor_573b844152316b8d: function(arg0, arg1, arg2, arg3, arg4) {
4835
+ arg0.scissor(arg1, arg2, arg3, arg4);
4836
+ },
4837
+ __wbg_setBindGroup_67bd9a0c57486387: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
4838
+ arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
4839
+ }, arguments); },
4840
+ __wbg_setBindGroup_9fdf11fd244aa68a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
4841
+ arg0.setBindGroup(arg1 >>> 0, arg2, getArrayU32FromWasm0(arg3, arg4), arg5, arg6 >>> 0);
4842
+ }, arguments); },
4843
+ __wbg_setBindGroup_a2a4442ac2a0be99: function(arg0, arg1, arg2) {
4844
+ arg0.setBindGroup(arg1 >>> 0, arg2);
4845
+ },
4846
+ __wbg_setBindGroup_a7e88440d0ecac88: function(arg0, arg1, arg2) {
4847
+ arg0.setBindGroup(arg1 >>> 0, arg2);
4848
+ },
4849
+ __wbg_setIndexBuffer_34f864cca07ffcec: function(arg0, arg1, arg2, arg3) {
4850
+ arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3);
4851
+ },
4852
+ __wbg_setIndexBuffer_495adb9486108a2f: function(arg0, arg1, arg2, arg3, arg4) {
4853
+ arg0.setIndexBuffer(arg1, __wbindgen_enum_GpuIndexFormat[arg2], arg3, arg4);
4854
+ },
4855
+ __wbg_setPipeline_092493bfd77760ee: function(arg0, arg1) {
4856
+ arg0.setPipeline(arg1);
4857
+ },
4858
+ __wbg_setPipeline_50cfc53a5d0eb1d7: function(arg0, arg1) {
4859
+ arg0.setPipeline(arg1);
4860
+ },
4861
+ __wbg_setScissorRect_ab5c9964f1440456: function(arg0, arg1, arg2, arg3, arg4) {
4862
+ arg0.setScissorRect(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
4863
+ },
4864
+ __wbg_setVertexBuffer_1ed692dc2726f6c3: function(arg0, arg1, arg2, arg3, arg4) {
4865
+ arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3, arg4);
4866
+ },
4867
+ __wbg_setVertexBuffer_cc6e95bb408da360: function(arg0, arg1, arg2, arg3) {
4868
+ arg0.setVertexBuffer(arg1 >>> 0, arg2, arg3);
4869
+ },
4870
+ __wbg_setViewport_de0ebf5f8450da7e: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
4871
+ arg0.setViewport(arg1, arg2, arg3, arg4, arg5, arg6);
4872
+ },
4873
+ __wbg_set_61e45ae8061eca11: function(arg0, arg1, arg2) {
4874
+ arg0.set(arg1, arg2 >>> 0);
4875
+ },
4876
+ __wbg_set_8535240470bf2500: function() { return handleError(function (arg0, arg1, arg2) {
4877
+ const ret = Reflect.set(arg0, arg1, arg2);
4878
+ return ret;
4879
+ }, arguments); },
4880
+ __wbg_set_a_9b35e9a1b60244b3: function(arg0, arg1) {
4881
+ arg0.a = arg1;
4882
+ },
4883
+ __wbg_set_access_67a4b0ae1c0f32f5: function(arg0, arg1) {
4884
+ arg0.access = __wbindgen_enum_GpuStorageTextureAccess[arg1];
4885
+ },
4886
+ __wbg_set_address_mode_u_1a44abe112b27750: function(arg0, arg1) {
4887
+ arg0.addressModeU = __wbindgen_enum_GpuAddressMode[arg1];
4888
+ },
4889
+ __wbg_set_address_mode_v_764da2dbc77dbf3e: function(arg0, arg1) {
4890
+ arg0.addressModeV = __wbindgen_enum_GpuAddressMode[arg1];
4891
+ },
4892
+ __wbg_set_address_mode_w_7c5135c7d56f9b4c: function(arg0, arg1) {
4893
+ arg0.addressModeW = __wbindgen_enum_GpuAddressMode[arg1];
4894
+ },
4895
+ __wbg_set_alpha_52d96a0bda4f4afe: function(arg0, arg1) {
4896
+ arg0.alpha = arg1;
4897
+ },
4898
+ __wbg_set_alpha_mode_5c1f4c4115bbe318: function(arg0, arg1) {
4899
+ arg0.alphaMode = __wbindgen_enum_GpuCanvasAlphaMode[arg1];
4900
+ },
4901
+ __wbg_set_alpha_to_coverage_enabled_36cef063cffb5d84: function(arg0, arg1) {
4902
+ arg0.alphaToCoverageEnabled = arg1 !== 0;
4903
+ },
4904
+ __wbg_set_array_layer_count_c2e975f5b62596bb: function(arg0, arg1) {
4905
+ arg0.arrayLayerCount = arg1 >>> 0;
4906
+ },
4907
+ __wbg_set_array_stride_eb9d409a95d2c1b3: function(arg0, arg1) {
4908
+ arg0.arrayStride = arg1;
4909
+ },
4910
+ __wbg_set_aspect_a453970e75d8e849: function(arg0, arg1) {
4911
+ arg0.aspect = __wbindgen_enum_GpuTextureAspect[arg1];
4912
+ },
4913
+ __wbg_set_attributes_edcbef656678a257: function(arg0, arg1) {
4914
+ arg0.attributes = arg1;
4915
+ },
4916
+ __wbg_set_b_5708a52cef50b19f: function(arg0, arg1) {
4917
+ arg0.b = arg1;
4918
+ },
4919
+ __wbg_set_base_array_layer_b67db9750fbc7053: function(arg0, arg1) {
4920
+ arg0.baseArrayLayer = arg1 >>> 0;
4921
+ },
4922
+ __wbg_set_base_mip_level_35f2fc3293e96083: function(arg0, arg1) {
4923
+ arg0.baseMipLevel = arg1 >>> 0;
4924
+ },
4925
+ __wbg_set_beginning_of_pass_write_index_8e570668cd8cad5e: function(arg0, arg1) {
4926
+ arg0.beginningOfPassWriteIndex = arg1 >>> 0;
4927
+ },
4928
+ __wbg_set_beginning_of_pass_write_index_ddfc55f615254cc1: function(arg0, arg1) {
4929
+ arg0.beginningOfPassWriteIndex = arg1 >>> 0;
4930
+ },
4931
+ __wbg_set_bind_group_layouts_436bd62a9b35e1ab: function(arg0, arg1) {
4932
+ arg0.bindGroupLayouts = arg1;
4933
+ },
4934
+ __wbg_set_binding_b575483e08d5ba4a: function(arg0, arg1) {
4935
+ arg0.binding = arg1 >>> 0;
4936
+ },
4937
+ __wbg_set_binding_c9feebb53a130ebe: function(arg0, arg1) {
4938
+ arg0.binding = arg1 >>> 0;
4939
+ },
4940
+ __wbg_set_blend_765238525504b1db: function(arg0, arg1) {
4941
+ arg0.blend = arg1;
4942
+ },
4943
+ __wbg_set_buffer_468874ee2bc9df02: function(arg0, arg1) {
4944
+ arg0.buffer = arg1;
4945
+ },
4946
+ __wbg_set_buffer_6c45652fb024e808: function(arg0, arg1) {
4947
+ arg0.buffer = arg1;
4948
+ },
4949
+ __wbg_set_buffer_83041e80a2b2c1b9: function(arg0, arg1) {
4950
+ arg0.buffer = arg1;
4951
+ },
4952
+ __wbg_set_buffers_986b265eda61fae6: function(arg0, arg1) {
4953
+ arg0.buffers = arg1;
4954
+ },
4955
+ __wbg_set_bytes_per_row_c127092e4fe9be22: function(arg0, arg1) {
4956
+ arg0.bytesPerRow = arg1 >>> 0;
4957
+ },
4958
+ __wbg_set_bytes_per_row_fecf7d0d8d5038d0: function(arg0, arg1) {
4959
+ arg0.bytesPerRow = arg1 >>> 0;
4960
+ },
4961
+ __wbg_set_clear_value_764be6f32f502d0a: function(arg0, arg1) {
4962
+ arg0.clearValue = arg1;
4963
+ },
4964
+ __wbg_set_code_0a82fa86cf58ca3b: function(arg0, arg1, arg2) {
4965
+ arg0.code = getStringFromWasm0(arg1, arg2);
4966
+ },
4967
+ __wbg_set_color_attachments_fad73def169d9610: function(arg0, arg1) {
4968
+ arg0.colorAttachments = arg1;
4969
+ },
4970
+ __wbg_set_color_c25fb8769b4f010f: function(arg0, arg1) {
4971
+ arg0.color = arg1;
4972
+ },
4973
+ __wbg_set_compare_1e2214a402af6db3: function(arg0, arg1) {
4974
+ arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
4975
+ },
4976
+ __wbg_set_compare_e61cc62d8f7e2191: function(arg0, arg1) {
4977
+ arg0.compare = __wbindgen_enum_GpuCompareFunction[arg1];
4978
+ },
4979
+ __wbg_set_compute_dc74d722ba27aa5b: function(arg0, arg1) {
4980
+ arg0.compute = arg1;
4981
+ },
4982
+ __wbg_set_count_39e1b3c03c19b528: function(arg0, arg1) {
4983
+ arg0.count = arg1 >>> 0;
4984
+ },
4985
+ __wbg_set_count_f285d8c62f4de679: function(arg0, arg1) {
4986
+ arg0.count = arg1 >>> 0;
4987
+ },
4988
+ __wbg_set_cull_mode_e6ca97d167dede04: function(arg0, arg1) {
4989
+ arg0.cullMode = __wbindgen_enum_GpuCullMode[arg1];
4990
+ },
4991
+ __wbg_set_depth_bias_clamp_e8da3e9edc037b18: function(arg0, arg1) {
4992
+ arg0.depthBiasClamp = arg1;
4993
+ },
4994
+ __wbg_set_depth_bias_edf83e7d032bdd2a: function(arg0, arg1) {
4995
+ arg0.depthBias = arg1;
4996
+ },
4997
+ __wbg_set_depth_bias_slope_scale_1746553a2d960310: function(arg0, arg1) {
4998
+ arg0.depthBiasSlopeScale = arg1;
4999
+ },
5000
+ __wbg_set_depth_clear_value_f6f20e460b0c4012: function(arg0, arg1) {
5001
+ arg0.depthClearValue = arg1;
5002
+ },
5003
+ __wbg_set_depth_compare_f18e709a5dc4a0b0: function(arg0, arg1) {
5004
+ arg0.depthCompare = __wbindgen_enum_GpuCompareFunction[arg1];
5005
+ },
5006
+ __wbg_set_depth_fail_op_45f4179ddfc376cd: function(arg0, arg1) {
5007
+ arg0.depthFailOp = __wbindgen_enum_GpuStencilOperation[arg1];
5008
+ },
5009
+ __wbg_set_depth_load_op_c3d15137e916dd5a: function(arg0, arg1) {
5010
+ arg0.depthLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
5011
+ },
5012
+ __wbg_set_depth_or_array_layers_17284e1eac0007a1: function(arg0, arg1) {
5013
+ arg0.depthOrArrayLayers = arg1 >>> 0;
5014
+ },
5015
+ __wbg_set_depth_read_only_9a8994459a0acf9e: function(arg0, arg1) {
5016
+ arg0.depthReadOnly = arg1 !== 0;
5017
+ },
5018
+ __wbg_set_depth_stencil_8716a627d44d796e: function(arg0, arg1) {
5019
+ arg0.depthStencil = arg1;
5020
+ },
5021
+ __wbg_set_depth_stencil_attachment_08fe1db9243adb49: function(arg0, arg1) {
5022
+ arg0.depthStencilAttachment = arg1;
5023
+ },
5024
+ __wbg_set_depth_store_op_881c8dbe0d67045d: function(arg0, arg1) {
5025
+ arg0.depthStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
5026
+ },
5027
+ __wbg_set_depth_write_enabled_9b608c3bf190f04a: function(arg0, arg1) {
5028
+ arg0.depthWriteEnabled = arg1 !== 0;
5029
+ },
5030
+ __wbg_set_device_bf67f52a587f9aab: function(arg0, arg1) {
5031
+ arg0.device = arg1;
5032
+ },
5033
+ __wbg_set_dimension_3144c827eb67b110: function(arg0, arg1) {
5034
+ arg0.dimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
5035
+ },
5036
+ __wbg_set_dimension_9054f7ab0acbfd31: function(arg0, arg1) {
5037
+ arg0.dimension = __wbindgen_enum_GpuTextureDimension[arg1];
5038
+ },
5039
+ __wbg_set_dst_factor_77c088c0ad43b684: function(arg0, arg1) {
5040
+ arg0.dstFactor = __wbindgen_enum_GpuBlendFactor[arg1];
5041
+ },
5042
+ __wbg_set_end_of_pass_write_index_568e7295b1b273a3: function(arg0, arg1) {
5043
+ arg0.endOfPassWriteIndex = arg1 >>> 0;
5044
+ },
5045
+ __wbg_set_end_of_pass_write_index_786588764311c9aa: function(arg0, arg1) {
5046
+ arg0.endOfPassWriteIndex = arg1 >>> 0;
5047
+ },
5048
+ __wbg_set_entries_247b5e665db79583: function(arg0, arg1) {
5049
+ arg0.entries = arg1;
5050
+ },
5051
+ __wbg_set_entries_bfbb6a7f04b96709: function(arg0, arg1) {
5052
+ arg0.entries = arg1;
5053
+ },
5054
+ __wbg_set_entry_point_1d7ecf099e15fa2b: function(arg0, arg1, arg2) {
5055
+ arg0.entryPoint = getStringFromWasm0(arg1, arg2);
5056
+ },
5057
+ __wbg_set_entry_point_3b13db51cfe0c5d6: function(arg0, arg1, arg2) {
5058
+ arg0.entryPoint = getStringFromWasm0(arg1, arg2);
5059
+ },
5060
+ __wbg_set_entry_point_a698bc91b472d5a9: function(arg0, arg1, arg2) {
5061
+ arg0.entryPoint = getStringFromWasm0(arg1, arg2);
5062
+ },
5063
+ __wbg_set_external_texture_a0db2eb13c76e01c: function(arg0, arg1) {
5064
+ arg0.externalTexture = arg1;
5065
+ },
5066
+ __wbg_set_fail_op_a6890cff6b560a14: function(arg0, arg1) {
5067
+ arg0.failOp = __wbindgen_enum_GpuStencilOperation[arg1];
5068
+ },
5069
+ __wbg_set_format_237b3e4047d1be9a: function(arg0, arg1) {
5070
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
5071
+ },
5072
+ __wbg_set_format_53479155b45c92ea: function(arg0, arg1) {
5073
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
5074
+ },
5075
+ __wbg_set_format_7c20bfc7e4802e1e: function(arg0, arg1) {
5076
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
5077
+ },
5078
+ __wbg_set_format_84af8ed546a319fa: function(arg0, arg1) {
5079
+ arg0.format = __wbindgen_enum_GpuVertexFormat[arg1];
5080
+ },
5081
+ __wbg_set_format_9f32450123336995: function(arg0, arg1) {
5082
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
5083
+ },
5084
+ __wbg_set_format_c9dcecebf9c1e619: function(arg0, arg1) {
5085
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
5086
+ },
5087
+ __wbg_set_format_d9d3420c1a9d1c59: function(arg0, arg1) {
5088
+ arg0.format = __wbindgen_enum_GpuTextureFormat[arg1];
5089
+ },
5090
+ __wbg_set_fragment_2c6f6192456fed1c: function(arg0, arg1) {
5091
+ arg0.fragment = arg1;
5092
+ },
5093
+ __wbg_set_front_face_fd34f06ac9239d11: function(arg0, arg1) {
5094
+ arg0.frontFace = __wbindgen_enum_GpuFrontFace[arg1];
5095
+ },
5096
+ __wbg_set_g_7bb456722103c5e6: function(arg0, arg1) {
5097
+ arg0.g = arg1;
5098
+ },
5099
+ __wbg_set_has_dynamic_offset_0c8a607543be8069: function(arg0, arg1) {
5100
+ arg0.hasDynamicOffset = arg1 !== 0;
5101
+ },
5102
+ __wbg_set_height_7d9d8f892e6964c6: function(arg0, arg1) {
5103
+ arg0.height = arg1 >>> 0;
5104
+ },
5105
+ __wbg_set_height_96611e96eee67c44: function(arg0, arg1) {
5106
+ arg0.height = arg1 >>> 0;
5107
+ },
5108
+ __wbg_set_height_bbeef8f354041577: function(arg0, arg1) {
5109
+ arg0.height = arg1 >>> 0;
5110
+ },
5111
+ __wbg_set_label_01228663ea03b92f: function(arg0, arg1, arg2) {
5112
+ arg0.label = getStringFromWasm0(arg1, arg2);
5113
+ },
5114
+ __wbg_set_label_13a2dd9810399e8b: function(arg0, arg1, arg2) {
5115
+ arg0.label = getStringFromWasm0(arg1, arg2);
5116
+ },
5117
+ __wbg_set_label_22e57f4c5b38215f: function(arg0, arg1, arg2) {
5118
+ arg0.label = getStringFromWasm0(arg1, arg2);
5119
+ },
5120
+ __wbg_set_label_3341f59be0eb3205: function(arg0, arg1, arg2) {
5121
+ arg0.label = getStringFromWasm0(arg1, arg2);
5122
+ },
5123
+ __wbg_set_label_382417d222111912: function(arg0, arg1, arg2) {
5124
+ arg0.label = getStringFromWasm0(arg1, arg2);
5125
+ },
5126
+ __wbg_set_label_4d049edb707ba31c: function(arg0, arg1, arg2) {
5127
+ arg0.label = getStringFromWasm0(arg1, arg2);
5128
+ },
5129
+ __wbg_set_label_5724e5c6286e8a4e: function(arg0, arg1, arg2) {
5130
+ arg0.label = getStringFromWasm0(arg1, arg2);
5131
+ },
5132
+ __wbg_set_label_66fc1d23dd10d4f5: function(arg0, arg1, arg2) {
5133
+ arg0.label = getStringFromWasm0(arg1, arg2);
5134
+ },
5135
+ __wbg_set_label_806446f85d68e201: function(arg0, arg1, arg2) {
5136
+ arg0.label = getStringFromWasm0(arg1, arg2);
5137
+ },
5138
+ __wbg_set_label_8354c6463558484f: function(arg0, arg1, arg2) {
5139
+ arg0.label = getStringFromWasm0(arg1, arg2);
5140
+ },
5141
+ __wbg_set_label_acd66edf00f8e40f: function(arg0, arg1, arg2) {
5142
+ arg0.label = getStringFromWasm0(arg1, arg2);
5143
+ },
5144
+ __wbg_set_label_b3da7636c69f1a4c: function(arg0, arg1, arg2) {
5145
+ arg0.label = getStringFromWasm0(arg1, arg2);
5146
+ },
5147
+ __wbg_set_label_b7f797c13bc822c4: function(arg0, arg1, arg2) {
5148
+ arg0.label = getStringFromWasm0(arg1, arg2);
5149
+ },
5150
+ __wbg_set_label_e026aa2aea731594: function(arg0, arg1, arg2) {
5151
+ arg0.label = getStringFromWasm0(arg1, arg2);
5152
+ },
5153
+ __wbg_set_label_e6bc3b86ef6deeb8: function(arg0, arg1, arg2) {
5154
+ arg0.label = getStringFromWasm0(arg1, arg2);
5155
+ },
5156
+ __wbg_set_label_e7f76bba99d72971: function(arg0, arg1, arg2) {
5157
+ arg0.label = getStringFromWasm0(arg1, arg2);
5158
+ },
5159
+ __wbg_set_layout_210c56f1b01e883b: function(arg0, arg1) {
5160
+ arg0.layout = arg1;
5161
+ },
5162
+ __wbg_set_layout_44943c4c7d78f826: function(arg0, arg1) {
5163
+ arg0.layout = arg1;
5164
+ },
5165
+ __wbg_set_layout_726c6ae6f5919730: function(arg0, arg1) {
5166
+ arg0.layout = arg1;
5167
+ },
5168
+ __wbg_set_load_op_103e6ce0a06327b3: function(arg0, arg1) {
5169
+ arg0.loadOp = __wbindgen_enum_GpuLoadOp[arg1];
5170
+ },
5171
+ __wbg_set_lod_max_clamp_3706b17de6a5a11a: function(arg0, arg1) {
5172
+ arg0.lodMaxClamp = arg1;
5173
+ },
5174
+ __wbg_set_lod_min_clamp_1f4b28d77d0c87c4: function(arg0, arg1) {
5175
+ arg0.lodMinClamp = arg1;
5176
+ },
5177
+ __wbg_set_mag_filter_2c8c212ff297b151: function(arg0, arg1) {
5178
+ arg0.magFilter = __wbindgen_enum_GpuFilterMode[arg1];
5179
+ },
5180
+ __wbg_set_mapped_at_creation_12773dff1bb6ea0f: function(arg0, arg1) {
5181
+ arg0.mappedAtCreation = arg1 !== 0;
5182
+ },
5183
+ __wbg_set_mask_94311bacf22c96b1: function(arg0, arg1) {
5184
+ arg0.mask = arg1 >>> 0;
5185
+ },
5186
+ __wbg_set_max_anisotropy_56bff110d0b4830f: function(arg0, arg1) {
5187
+ arg0.maxAnisotropy = arg1;
5188
+ },
5189
+ __wbg_set_min_binding_size_164df827e02821e1: function(arg0, arg1) {
5190
+ arg0.minBindingSize = arg1;
5191
+ },
5192
+ __wbg_set_min_filter_66d70efb70601bf9: function(arg0, arg1) {
5193
+ arg0.minFilter = __wbindgen_enum_GpuFilterMode[arg1];
5194
+ },
5195
+ __wbg_set_mip_level_7f56c1c607dda5cf: function(arg0, arg1) {
5196
+ arg0.mipLevel = arg1 >>> 0;
5197
+ },
5198
+ __wbg_set_mip_level_count_3402f5315a423b69: function(arg0, arg1) {
5199
+ arg0.mipLevelCount = arg1 >>> 0;
5200
+ },
5201
+ __wbg_set_mip_level_count_ed029120a0ee12b8: function(arg0, arg1) {
5202
+ arg0.mipLevelCount = arg1 >>> 0;
5203
+ },
5204
+ __wbg_set_mipmap_filter_1b3d153bd834ec26: function(arg0, arg1) {
5205
+ arg0.mipmapFilter = __wbindgen_enum_GpuMipmapFilterMode[arg1];
5206
+ },
5207
+ __wbg_set_module_119c125107e59165: function(arg0, arg1) {
5208
+ arg0.module = arg1;
5209
+ },
5210
+ __wbg_set_module_3336e0ce2672c07c: function(arg0, arg1) {
5211
+ arg0.module = arg1;
5212
+ },
5213
+ __wbg_set_module_af2f871a0bed003c: function(arg0, arg1) {
5214
+ arg0.module = arg1;
5215
+ },
5216
+ __wbg_set_multisample_1cdb4998c4f73341: function(arg0, arg1) {
5217
+ arg0.multisample = arg1;
5218
+ },
5219
+ __wbg_set_multisampled_e9d7bed0e68d1d6f: function(arg0, arg1) {
5220
+ arg0.multisampled = arg1 !== 0;
5221
+ },
5222
+ __wbg_set_offset_01c04218a4ccfa08: function(arg0, arg1) {
5223
+ arg0.offset = arg1;
5224
+ },
5225
+ __wbg_set_offset_5ea55c758ce6f103: function(arg0, arg1) {
5226
+ arg0.offset = arg1;
5227
+ },
5228
+ __wbg_set_offset_bd11f79890456c6f: function(arg0, arg1) {
5229
+ arg0.offset = arg1;
5230
+ },
5231
+ __wbg_set_offset_f07a73165707eb4c: function(arg0, arg1) {
5232
+ arg0.offset = arg1;
5233
+ },
5234
+ __wbg_set_operation_845ee9de4c1808be: function(arg0, arg1) {
5235
+ arg0.operation = __wbindgen_enum_GpuBlendOperation[arg1];
5236
+ },
5237
+ __wbg_set_origin_6be40076fb0623f4: function(arg0, arg1) {
5238
+ arg0.origin = arg1;
5239
+ },
5240
+ __wbg_set_pass_op_f4a566b4a6b819e0: function(arg0, arg1) {
5241
+ arg0.passOp = __wbindgen_enum_GpuStencilOperation[arg1];
5242
+ },
5243
+ __wbg_set_power_preference_0721cf46746c0c7d: function(arg0, arg1) {
5244
+ arg0.powerPreference = __wbindgen_enum_GpuPowerPreference[arg1];
5245
+ },
5246
+ __wbg_set_primitive_94234ea756a4c469: function(arg0, arg1) {
5247
+ arg0.primitive = arg1;
5248
+ },
5249
+ __wbg_set_query_set_667d2dcfcedd1ec2: function(arg0, arg1) {
5250
+ arg0.querySet = arg1;
5251
+ },
5252
+ __wbg_set_query_set_aadbb433c8390a5c: function(arg0, arg1) {
5253
+ arg0.querySet = arg1;
5254
+ },
5255
+ __wbg_set_r_13b3eba61d4ba4d9: function(arg0, arg1) {
5256
+ arg0.r = arg1;
5257
+ },
5258
+ __wbg_set_required_features_5202fa8cd082e531: function(arg0, arg1) {
5259
+ arg0.requiredFeatures = arg1;
5260
+ },
5261
+ __wbg_set_resolve_target_8251ec563ce24501: function(arg0, arg1) {
5262
+ arg0.resolveTarget = arg1;
5263
+ },
5264
+ __wbg_set_resource_c73d0c2d815f7211: function(arg0, arg1) {
5265
+ arg0.resource = arg1;
5266
+ },
5267
+ __wbg_set_rows_per_image_00c8e938dae40dae: function(arg0, arg1) {
5268
+ arg0.rowsPerImage = arg1 >>> 0;
5269
+ },
5270
+ __wbg_set_rows_per_image_e6e2c0c4a7e4fa8d: function(arg0, arg1) {
5271
+ arg0.rowsPerImage = arg1 >>> 0;
5272
+ },
5273
+ __wbg_set_sample_count_05dcc9952f4fa7ac: function(arg0, arg1) {
5274
+ arg0.sampleCount = arg1 >>> 0;
5275
+ },
5276
+ __wbg_set_sample_type_93886b8f9794f85c: function(arg0, arg1) {
5277
+ arg0.sampleType = __wbindgen_enum_GpuTextureSampleType[arg1];
5278
+ },
5279
+ __wbg_set_sampler_02989e99b27a50db: function(arg0, arg1) {
5280
+ arg0.sampler = arg1;
5281
+ },
5282
+ __wbg_set_shader_location_33bfc2cc417fdde2: function(arg0, arg1) {
5283
+ arg0.shaderLocation = arg1 >>> 0;
5284
+ },
5285
+ __wbg_set_size_b3e6b2bf58d62082: function(arg0, arg1) {
5286
+ arg0.size = arg1;
5287
+ },
5288
+ __wbg_set_size_c2a556d5571231f5: function(arg0, arg1) {
5289
+ arg0.size = arg1;
5290
+ },
5291
+ __wbg_set_size_f7b29f6cb1669c4d: function(arg0, arg1) {
5292
+ arg0.size = arg1;
5293
+ },
5294
+ __wbg_set_src_factor_deefdfd4b6427b5e: function(arg0, arg1) {
5295
+ arg0.srcFactor = __wbindgen_enum_GpuBlendFactor[arg1];
5296
+ },
5297
+ __wbg_set_stencil_back_9971eece60c613eb: function(arg0, arg1) {
5298
+ arg0.stencilBack = arg1;
5299
+ },
5300
+ __wbg_set_stencil_clear_value_4b82f2d7e6d9f496: function(arg0, arg1) {
5301
+ arg0.stencilClearValue = arg1 >>> 0;
5302
+ },
5303
+ __wbg_set_stencil_front_c82ccf19db426a5b: function(arg0, arg1) {
5304
+ arg0.stencilFront = arg1;
5305
+ },
5306
+ __wbg_set_stencil_load_op_dbc3af9713146f24: function(arg0, arg1) {
5307
+ arg0.stencilLoadOp = __wbindgen_enum_GpuLoadOp[arg1];
5308
+ },
5309
+ __wbg_set_stencil_read_mask_926bce469fa8eaf3: function(arg0, arg1) {
5310
+ arg0.stencilReadMask = arg1 >>> 0;
5311
+ },
5312
+ __wbg_set_stencil_read_only_88136eaf94225fec: function(arg0, arg1) {
5313
+ arg0.stencilReadOnly = arg1 !== 0;
5314
+ },
5315
+ __wbg_set_stencil_store_op_e10e50255bf42e8b: function(arg0, arg1) {
5316
+ arg0.stencilStoreOp = __wbindgen_enum_GpuStoreOp[arg1];
5317
+ },
5318
+ __wbg_set_stencil_write_mask_3a7b75284ae036de: function(arg0, arg1) {
5319
+ arg0.stencilWriteMask = arg1 >>> 0;
5320
+ },
5321
+ __wbg_set_step_mode_2a36020da93d6f16: function(arg0, arg1) {
5322
+ arg0.stepMode = __wbindgen_enum_GpuVertexStepMode[arg1];
5323
+ },
5324
+ __wbg_set_storage_texture_50af47fec531be02: function(arg0, arg1) {
5325
+ arg0.storageTexture = arg1;
5326
+ },
5327
+ __wbg_set_store_op_23c150f1deb52749: function(arg0, arg1) {
5328
+ arg0.storeOp = __wbindgen_enum_GpuStoreOp[arg1];
5329
+ },
5330
+ __wbg_set_strip_index_format_bd4035f66052e74e: function(arg0, arg1) {
5331
+ arg0.stripIndexFormat = __wbindgen_enum_GpuIndexFormat[arg1];
5332
+ },
5333
+ __wbg_set_targets_d4d849b9c6abd35a: function(arg0, arg1) {
5334
+ arg0.targets = arg1;
5335
+ },
5336
+ __wbg_set_texture_884f2777c0fe1e91: function(arg0, arg1) {
5337
+ arg0.texture = arg1;
5338
+ },
5339
+ __wbg_set_texture_a1baf7da91d20351: function(arg0, arg1) {
5340
+ arg0.texture = arg1;
5341
+ },
5342
+ __wbg_set_timestamp_writes_7fa18118aa24ddc1: function(arg0, arg1) {
5343
+ arg0.timestampWrites = arg1;
5344
+ },
5345
+ __wbg_set_timestamp_writes_fdf8168751575b7f: function(arg0, arg1) {
5346
+ arg0.timestampWrites = arg1;
5347
+ },
5348
+ __wbg_set_topology_0a07d5f484aff275: function(arg0, arg1) {
5349
+ arg0.topology = __wbindgen_enum_GpuPrimitiveTopology[arg1];
5350
+ },
5351
+ __wbg_set_type_109702a7ec65b49d: function(arg0, arg1) {
5352
+ arg0.type = __wbindgen_enum_GpuSamplerBindingType[arg1];
5353
+ },
5354
+ __wbg_set_type_55112c374bcc5a9d: function(arg0, arg1) {
5355
+ arg0.type = __wbindgen_enum_GpuBufferBindingType[arg1];
5356
+ },
5357
+ __wbg_set_type_9b9ab9961bd236f7: function(arg0, arg1) {
5358
+ arg0.type = __wbindgen_enum_GpuQueryType[arg1];
5359
+ },
5360
+ __wbg_set_unclipped_depth_b15740038a226817: function(arg0, arg1) {
5361
+ arg0.unclippedDepth = arg1 !== 0;
5362
+ },
5363
+ __wbg_set_usage_75d0e81d39ff5284: function(arg0, arg1) {
5364
+ arg0.usage = arg1 >>> 0;
5365
+ },
5366
+ __wbg_set_usage_ac04cadda4108c1a: function(arg0, arg1) {
5367
+ arg0.usage = arg1 >>> 0;
5368
+ },
5369
+ __wbg_set_usage_ad30cd3b0e0f4244: function(arg0, arg1) {
5370
+ arg0.usage = arg1 >>> 0;
5371
+ },
5372
+ __wbg_set_usage_cc34543608cf3335: function(arg0, arg1) {
5373
+ arg0.usage = arg1 >>> 0;
5374
+ },
5375
+ __wbg_set_vertex_13029c78ba2f0430: function(arg0, arg1) {
5376
+ arg0.vertex = arg1;
5377
+ },
5378
+ __wbg_set_view_6f2831c0da43be15: function(arg0, arg1) {
5379
+ arg0.view = arg1;
5380
+ },
5381
+ __wbg_set_view_b18c2cccd427261d: function(arg0, arg1) {
5382
+ arg0.view = arg1;
5383
+ },
5384
+ __wbg_set_view_dimension_50f3edb06107948f: function(arg0, arg1) {
5385
+ arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
5386
+ },
5387
+ __wbg_set_view_dimension_925bb358df1f2b9d: function(arg0, arg1) {
5388
+ arg0.viewDimension = __wbindgen_enum_GpuTextureViewDimension[arg1];
5389
+ },
5390
+ __wbg_set_view_formats_3d2a72ffb1f55a75: function(arg0, arg1) {
5391
+ arg0.viewFormats = arg1;
5392
+ },
5393
+ __wbg_set_view_formats_ae87e8e12aa858fc: function(arg0, arg1) {
5394
+ arg0.viewFormats = arg1;
5395
+ },
5396
+ __wbg_set_visibility_bdebc70a7c0f236d: function(arg0, arg1) {
5397
+ arg0.visibility = arg1 >>> 0;
5398
+ },
5399
+ __wbg_set_width_40592253da7b2113: function(arg0, arg1) {
5400
+ arg0.width = arg1 >>> 0;
5401
+ },
5402
+ __wbg_set_width_49ac9b7d914afc85: function(arg0, arg1) {
5403
+ arg0.width = arg1 >>> 0;
5404
+ },
5405
+ __wbg_set_width_8e30d010cd66830d: function(arg0, arg1) {
5406
+ arg0.width = arg1 >>> 0;
5407
+ },
5408
+ __wbg_set_write_mask_c03e8a45a9236e80: function(arg0, arg1) {
5409
+ arg0.writeMask = arg1 >>> 0;
5410
+ },
5411
+ __wbg_set_x_3c1cb8191b848172: function(arg0, arg1) {
5412
+ arg0.x = arg1 >>> 0;
5413
+ },
5414
+ __wbg_set_y_9024331910317eff: function(arg0, arg1) {
5415
+ arg0.y = arg1 >>> 0;
5416
+ },
5417
+ __wbg_set_z_b6182f4c230116a7: function(arg0, arg1) {
5418
+ arg0.z = arg1 >>> 0;
5419
+ },
5420
+ __wbg_shaderSource_4cf90af97621ff49: function(arg0, arg1, arg2, arg3) {
5421
+ arg0.shaderSource(arg1, getStringFromWasm0(arg2, arg3));
5422
+ },
5423
+ __wbg_shaderSource_c3469dc2221dd528: function(arg0, arg1, arg2, arg3) {
5424
+ arg0.shaderSource(arg1, getStringFromWasm0(arg2, arg3));
5425
+ },
5426
+ __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
5427
+ const ret = typeof global === 'undefined' ? null : global;
5428
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
5429
+ },
5430
+ __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
5431
+ const ret = typeof globalThis === 'undefined' ? null : globalThis;
5432
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
5433
+ },
5434
+ __wbg_static_accessor_SELF_146583524fe1469b: function() {
5435
+ const ret = typeof self === 'undefined' ? null : self;
5436
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
5437
+ },
5438
+ __wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
5439
+ const ret = typeof window === 'undefined' ? null : window;
5440
+ return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
5441
+ },
5442
+ __wbg_status_c45b3b9b3033184a: function(arg0) {
5443
+ const ret = arg0.status;
5444
+ return ret;
5445
+ },
5446
+ __wbg_stencilFuncSeparate_35136c4e5153406f: function(arg0, arg1, arg2, arg3, arg4) {
5447
+ arg0.stencilFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3, arg4 >>> 0);
5448
+ },
5449
+ __wbg_stencilFuncSeparate_814300446c2969ef: function(arg0, arg1, arg2, arg3, arg4) {
5450
+ arg0.stencilFuncSeparate(arg1 >>> 0, arg2 >>> 0, arg3, arg4 >>> 0);
5451
+ },
5452
+ __wbg_stencilMaskSeparate_49367b0b5883a8bd: function(arg0, arg1, arg2) {
5453
+ arg0.stencilMaskSeparate(arg1 >>> 0, arg2 >>> 0);
5454
+ },
5455
+ __wbg_stencilMaskSeparate_63976cc45fb94d84: function(arg0, arg1, arg2) {
5456
+ arg0.stencilMaskSeparate(arg1 >>> 0, arg2 >>> 0);
5457
+ },
5458
+ __wbg_stencilMask_1c99b79b516d12dd: function(arg0, arg1) {
5459
+ arg0.stencilMask(arg1 >>> 0);
5460
+ },
5461
+ __wbg_stencilMask_9a844dc58a89992f: function(arg0, arg1) {
5462
+ arg0.stencilMask(arg1 >>> 0);
5463
+ },
5464
+ __wbg_stencilOpSeparate_b2cb9af05b803e02: function(arg0, arg1, arg2, arg3, arg4) {
5465
+ arg0.stencilOpSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
5466
+ },
5467
+ __wbg_stencilOpSeparate_c77fcb47561d0aee: function(arg0, arg1, arg2, arg3, arg4) {
5468
+ arg0.stencilOpSeparate(arg1 >>> 0, arg2 >>> 0, arg3 >>> 0, arg4 >>> 0);
5469
+ },
5470
+ __wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
5471
+ const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
5472
+ return ret;
5473
+ },
5474
+ __wbg_submit_fc5b9a1154201a58: function(arg0, arg1) {
5475
+ arg0.submit(arg1);
5476
+ },
5477
+ __wbg_texImage2D_3813406af5bf54c8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5478
+ arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5479
+ }, arguments); },
5480
+ __wbg_texImage2D_5abd8779d1d033c7: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5481
+ arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5482
+ }, arguments); },
5483
+ __wbg_texImage2D_8d168171984f2a40: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5484
+ arg0.texImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5485
+ }, arguments); },
5486
+ __wbg_texImage3D_bdd9bebe42ed1f52: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
5487
+ arg0.texImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8 >>> 0, arg9 >>> 0, arg10);
5488
+ }, arguments); },
5489
+ __wbg_texImage3D_ef16a1f721b3f908: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10) {
5490
+ arg0.texImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8 >>> 0, arg9 >>> 0, arg10);
5491
+ }, arguments); },
5492
+ __wbg_texParameteri_1fc451e0964fc91c: function(arg0, arg1, arg2, arg3) {
5493
+ arg0.texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
5494
+ },
5495
+ __wbg_texParameteri_9d0daa263d3a863f: function(arg0, arg1, arg2, arg3) {
5496
+ arg0.texParameteri(arg1 >>> 0, arg2 >>> 0, arg3);
5497
+ },
5498
+ __wbg_texStorage2D_7f947efc63dac273: function(arg0, arg1, arg2, arg3, arg4, arg5) {
5499
+ arg0.texStorage2D(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
5500
+ },
5501
+ __wbg_texStorage3D_f8f2e4b3386736f9: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
5502
+ arg0.texStorage3D(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5, arg6);
5503
+ },
5504
+ __wbg_texSubImage2D_047380bb2660e4f9: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5505
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5506
+ }, arguments); },
5507
+ __wbg_texSubImage2D_5058af3d30a8e205: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5508
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5509
+ }, arguments); },
5510
+ __wbg_texSubImage2D_6a376bfc3a31436b: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5511
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5512
+ }, arguments); },
5513
+ __wbg_texSubImage2D_98c43894eb217aa7: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5514
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5515
+ }, arguments); },
5516
+ __wbg_texSubImage2D_bed5e7a3cd81d409: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5517
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5518
+ }, arguments); },
5519
+ __wbg_texSubImage2D_d1af697e69f8a9e4: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5520
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5521
+ }, arguments); },
5522
+ __wbg_texSubImage2D_d3cd09d0ffcb27be: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5523
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5524
+ }, arguments); },
5525
+ __wbg_texSubImage2D_e107b4f88c19b920: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9) {
5526
+ arg0.texSubImage2D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7 >>> 0, arg8 >>> 0, arg9);
5527
+ }, arguments); },
5528
+ __wbg_texSubImage3D_45e498ae6298998c: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
5529
+ arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
5530
+ }, arguments); },
5531
+ __wbg_texSubImage3D_4fdd4cd95a2925c2: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
5532
+ arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
5533
+ }, arguments); },
5534
+ __wbg_texSubImage3D_6cb6cfd732dad145: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
5535
+ arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
5536
+ }, arguments); },
5537
+ __wbg_texSubImage3D_8077e90ec309c414: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
5538
+ arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
5539
+ }, arguments); },
5540
+ __wbg_texSubImage3D_93b38c69acb735c8: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
5541
+ arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
5542
+ }, arguments); },
5543
+ __wbg_texSubImage3D_c9e5a071796d412f: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
5544
+ arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
5545
+ }, arguments); },
5546
+ __wbg_texSubImage3D_feebaf7f0f4594c6: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11) {
5547
+ arg0.texSubImage3D(arg1 >>> 0, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9 >>> 0, arg10 >>> 0, arg11);
5548
+ }, arguments); },
5549
+ __wbg_then_16d107c451e9905d: function(arg0, arg1, arg2) {
5550
+ const ret = arg0.then(arg1, arg2);
5551
+ return ret;
5552
+ },
5553
+ __wbg_then_4a0b9283a66c4a8a: function(arg0, arg1, arg2) {
5554
+ const ret = arg0.then(arg1, arg2);
5555
+ return ret;
5556
+ },
5557
+ __wbg_then_6ec10ae38b3e92f7: function(arg0, arg1) {
5558
+ const ret = arg0.then(arg1);
5559
+ return ret;
5560
+ },
5561
+ __wbg_uniform1f_62692c8fa8e7bf1e: function(arg0, arg1, arg2) {
5562
+ arg0.uniform1f(arg1, arg2);
5563
+ },
5564
+ __wbg_uniform1f_b79d0c5667f9fb40: function(arg0, arg1, arg2) {
5565
+ arg0.uniform1f(arg1, arg2);
5566
+ },
5567
+ __wbg_uniform1i_5830de6702add20a: function(arg0, arg1, arg2) {
5568
+ arg0.uniform1i(arg1, arg2);
5569
+ },
5570
+ __wbg_uniform1i_7621f908f78177df: function(arg0, arg1, arg2) {
5571
+ arg0.uniform1i(arg1, arg2);
5572
+ },
5573
+ __wbg_uniform1ui_cd7ad5581093b3df: function(arg0, arg1, arg2) {
5574
+ arg0.uniform1ui(arg1, arg2 >>> 0);
5575
+ },
5576
+ __wbg_uniform2fv_1b43656b33177d21: function(arg0, arg1, arg2, arg3) {
5577
+ arg0.uniform2fv(arg1, getArrayF32FromWasm0(arg2, arg3));
5578
+ },
5579
+ __wbg_uniform2fv_948dab6a82b428ac: function(arg0, arg1, arg2, arg3) {
5580
+ arg0.uniform2fv(arg1, getArrayF32FromWasm0(arg2, arg3));
5581
+ },
5582
+ __wbg_uniform2iv_859048b9d60f46ae: function(arg0, arg1, arg2, arg3) {
5583
+ arg0.uniform2iv(arg1, getArrayI32FromWasm0(arg2, arg3));
5584
+ },
5585
+ __wbg_uniform2iv_f84a24961c0cfcd0: function(arg0, arg1, arg2, arg3) {
5586
+ arg0.uniform2iv(arg1, getArrayI32FromWasm0(arg2, arg3));
5587
+ },
5588
+ __wbg_uniform2uiv_8a9cb3155271213b: function(arg0, arg1, arg2, arg3) {
5589
+ arg0.uniform2uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
2855
5590
  },
2856
- __wbg___wbindgen_is_object_a27215656b807791: function(arg0) {
2857
- const val = arg0;
2858
- const ret = typeof(val) === 'object' && val !== null;
2859
- return ret;
5591
+ __wbg_uniform3fv_8ecb5ebb510b7bce: function(arg0, arg1, arg2, arg3) {
5592
+ arg0.uniform3fv(arg1, getArrayF32FromWasm0(arg2, arg3));
2860
5593
  },
2861
- __wbg___wbindgen_is_string_ea5e6cc2e4141dfe: function(arg0) {
2862
- const ret = typeof(arg0) === 'string';
2863
- return ret;
5594
+ __wbg_uniform3fv_95d1933ea1440725: function(arg0, arg1, arg2, arg3) {
5595
+ arg0.uniform3fv(arg1, getArrayF32FromWasm0(arg2, arg3));
2864
5596
  },
2865
- __wbg___wbindgen_is_undefined_c05833b95a3cf397: function(arg0) {
2866
- const ret = arg0 === undefined;
2867
- return ret;
5597
+ __wbg_uniform3iv_09abae5eabd6b9d6: function(arg0, arg1, arg2, arg3) {
5598
+ arg0.uniform3iv(arg1, getArrayI32FromWasm0(arg2, arg3));
2868
5599
  },
2869
- __wbg___wbindgen_throw_344f42d3211c4765: function(arg0, arg1) {
2870
- throw new Error(getStringFromWasm0(arg0, arg1));
5600
+ __wbg_uniform3iv_a3a7008990fd84f0: function(arg0, arg1, arg2, arg3) {
5601
+ arg0.uniform3iv(arg1, getArrayI32FromWasm0(arg2, arg3));
2871
5602
  },
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;
5603
+ __wbg_uniform3uiv_3c0b163732f5b8f0: function(arg0, arg1, arg2, arg3) {
5604
+ arg0.uniform3uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
2879
5605
  },
2880
- __wbg_error_96e899f14d8344a2: function(arg0, arg1) {
2881
- console.error(getStringFromWasm0(arg0, arg1));
5606
+ __wbg_uniform4f_9ff60fc65b0ed726: function(arg0, arg1, arg2, arg3, arg4, arg5) {
5607
+ arg0.uniform4f(arg1, arg2, arg3, arg4, arg5);
2882
5608
  },
2883
- __wbg_getDate_a1a40c1c5f40fe3b: function(arg0) {
2884
- const ret = arg0.getDate();
2885
- return ret;
5609
+ __wbg_uniform4f_b25e39808b830021: function(arg0, arg1, arg2, arg3, arg4, arg5) {
5610
+ arg0.uniform4f(arg1, arg2, arg3, arg4, arg5);
2886
5611
  },
2887
- __wbg_getDay_aa318cce5da74c49: function(arg0) {
2888
- const ret = arg0.getDay();
2889
- return ret;
5612
+ __wbg_uniform4fv_4ca8c114ca3de099: function(arg0, arg1, arg2, arg3) {
5613
+ arg0.uniform4fv(arg1, getArrayF32FromWasm0(arg2, arg3));
2890
5614
  },
2891
- __wbg_getFullYear_6af8b229792ae254: function(arg0) {
2892
- const ret = arg0.getFullYear();
2893
- return ret;
5615
+ __wbg_uniform4fv_674a247aeb15012d: function(arg0, arg1, arg2, arg3) {
5616
+ arg0.uniform4fv(arg1, getArrayF32FromWasm0(arg2, arg3));
2894
5617
  },
2895
- __wbg_getHours_9f6561095682ce51: function(arg0) {
2896
- const ret = arg0.getHours();
2897
- return ret;
5618
+ __wbg_uniform4iv_45ab52abcb3f882c: function(arg0, arg1, arg2, arg3) {
5619
+ arg0.uniform4iv(arg1, getArrayI32FromWasm0(arg2, arg3));
2898
5620
  },
2899
- __wbg_getMinutes_b0d5cd90bf9b8f22: function(arg0) {
2900
- const ret = arg0.getMinutes();
2901
- return ret;
5621
+ __wbg_uniform4iv_d02934d7b94df609: function(arg0, arg1, arg2, arg3) {
5622
+ arg0.uniform4iv(arg1, getArrayI32FromWasm0(arg2, arg3));
2902
5623
  },
2903
- __wbg_getMonth_fffe29d654d5eb69: function(arg0) {
2904
- const ret = arg0.getMonth();
2905
- return ret;
5624
+ __wbg_uniform4uiv_0d1a8ed214f10c31: function(arg0, arg1, arg2, arg3) {
5625
+ arg0.uniform4uiv(arg1, getArrayU32FromWasm0(arg2, arg3));
2906
5626
  },
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;
5627
+ __wbg_uniformBlockBinding_a9ed6b750199e03c: function(arg0, arg1, arg2, arg3) {
5628
+ arg0.uniformBlockBinding(arg1, arg2 >>> 0, arg3 >>> 0);
2913
5629
  },
2914
- __wbg_msCrypto_bd5a034af96bcba6: function(arg0) {
2915
- const ret = arg0.msCrypto;
2916
- return ret;
5630
+ __wbg_uniformMatrix2fv_769725d64641341f: function(arg0, arg1, arg2, arg3, arg4) {
5631
+ arg0.uniformMatrix2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
2917
5632
  },
2918
- __wbg_new_0_3da9e97f24fc69be: function() {
2919
- const ret = new Date();
2920
- return ret;
5633
+ __wbg_uniformMatrix2fv_9284424cc6aac672: function(arg0, arg1, arg2, arg3, arg4) {
5634
+ arg0.uniformMatrix2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
2921
5635
  },
2922
- __wbg_new_with_length_e6785c33c8e4cce8: function(arg0) {
2923
- const ret = new Uint8Array(arg0 >>> 0);
2924
- return ret;
5636
+ __wbg_uniformMatrix2x3fv_dba00c4fc8eefe47: function(arg0, arg1, arg2, arg3, arg4) {
5637
+ arg0.uniformMatrix2x3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
2925
5638
  },
2926
- __wbg_node_84ea875411254db1: function(arg0) {
2927
- const ret = arg0.node;
2928
- return ret;
5639
+ __wbg_uniformMatrix2x4fv_d801a561c3c18169: function(arg0, arg1, arg2, arg3, arg4) {
5640
+ arg0.uniformMatrix2x4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
2929
5641
  },
2930
- __wbg_now_86c0d4ba3fa605b8: function() {
2931
- const ret = Date.now();
5642
+ __wbg_uniformMatrix3fv_33e96c7d29dc1e22: function(arg0, arg1, arg2, arg3, arg4) {
5643
+ arg0.uniformMatrix3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
5644
+ },
5645
+ __wbg_uniformMatrix3fv_568aa181379c8a75: function(arg0, arg1, arg2, arg3, arg4) {
5646
+ arg0.uniformMatrix3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
5647
+ },
5648
+ __wbg_uniformMatrix3x2fv_ce43e8186ea60a1e: function(arg0, arg1, arg2, arg3, arg4) {
5649
+ arg0.uniformMatrix3x2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
5650
+ },
5651
+ __wbg_uniformMatrix3x4fv_8abccc5745b0dd90: function(arg0, arg1, arg2, arg3, arg4) {
5652
+ arg0.uniformMatrix3x4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
5653
+ },
5654
+ __wbg_uniformMatrix4fv_25115a23e04f6db7: function(arg0, arg1, arg2, arg3, arg4) {
5655
+ arg0.uniformMatrix4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
5656
+ },
5657
+ __wbg_uniformMatrix4fv_423b958042692150: function(arg0, arg1, arg2, arg3, arg4) {
5658
+ arg0.uniformMatrix4fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
5659
+ },
5660
+ __wbg_uniformMatrix4x2fv_1ac2bf986a322e3f: function(arg0, arg1, arg2, arg3, arg4) {
5661
+ arg0.uniformMatrix4x2fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
5662
+ },
5663
+ __wbg_uniformMatrix4x3fv_8640fa85b90ea910: function(arg0, arg1, arg2, arg3, arg4) {
5664
+ arg0.uniformMatrix4x3fv(arg1, arg2 !== 0, getArrayF32FromWasm0(arg3, arg4));
5665
+ },
5666
+ __wbg_unmap_50b3be4aaf23fa39: function(arg0) {
5667
+ arg0.unmap();
5668
+ },
5669
+ __wbg_useProgram_182d120fe476921b: function(arg0, arg1) {
5670
+ arg0.useProgram(arg1);
5671
+ },
5672
+ __wbg_useProgram_49495850b446fa56: function(arg0, arg1) {
5673
+ arg0.useProgram(arg1);
5674
+ },
5675
+ __wbg_versions_276b2795b1c6a219: function(arg0) {
5676
+ const ret = arg0.versions;
2932
5677
  return ret;
2933
5678
  },
2934
- __wbg_parse_1c0d8a8656d7e016: function() { return handleError(function (arg0, arg1) {
2935
- const ret = JSON.parse(getStringFromWasm0(arg0, arg1));
5679
+ __wbg_vertexAttribDivisorANGLE_978337b09d11ed84: function(arg0, arg1, arg2) {
5680
+ arg0.vertexAttribDivisorANGLE(arg1 >>> 0, arg2 >>> 0);
5681
+ },
5682
+ __wbg_vertexAttribDivisor_fb31b5ed9bc856da: function(arg0, arg1, arg2) {
5683
+ arg0.vertexAttribDivisor(arg1 >>> 0, arg2 >>> 0);
5684
+ },
5685
+ __wbg_vertexAttribIPointer_de08a8d8b625e253: function(arg0, arg1, arg2, arg3, arg4, arg5) {
5686
+ arg0.vertexAttribIPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4, arg5);
5687
+ },
5688
+ __wbg_vertexAttribPointer_a8f0af57269c2067: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
5689
+ arg0.vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
5690
+ },
5691
+ __wbg_vertexAttribPointer_b300c8e000cdac93: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
5692
+ arg0.vertexAttribPointer(arg1 >>> 0, arg2, arg3 >>> 0, arg4 !== 0, arg5, arg6);
5693
+ },
5694
+ __wbg_viewport_affdf15c559df1e2: function(arg0, arg1, arg2, arg3, arg4) {
5695
+ arg0.viewport(arg1, arg2, arg3, arg4);
5696
+ },
5697
+ __wbg_viewport_e8a16ca4a5085e5f: function(arg0, arg1, arg2, arg3, arg4) {
5698
+ arg0.viewport(arg1, arg2, arg3, arg4);
5699
+ },
5700
+ __wbg_width_6d9315ecc7140ff6: function(arg0) {
5701
+ const ret = arg0.width;
2936
5702
  return ret;
5703
+ },
5704
+ __wbg_writeBuffer_7d54524c36f1c7e2: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
5705
+ arg0.writeBuffer(arg1, arg2, arg3, arg4, arg5);
2937
5706
  }, arguments); },
2938
- __wbg_process_44c7a14e11e9f69e: function(arg0) {
2939
- const ret = arg0.process;
5707
+ __wbg_writeTexture_9d4c493be748d189: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
5708
+ arg0.writeTexture(arg1, arg2, arg3, arg4);
5709
+ }, arguments); },
5710
+ __wbindgen_cast_0000000000000001: function(arg0, arg1) {
5711
+ // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 2255, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
5712
+ const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h1592ff3f91e1224b);
2940
5713
  return ret;
2941
5714
  },
2942
- __wbg_prototypesetcall_4770620bbe4688a0: function(arg0, arg1, arg2) {
2943
- Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
5715
+ __wbindgen_cast_0000000000000002: function(arg0, arg1) {
5716
+ // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 6372, ret: Result(Unit), inner_ret: Some(Result(Unit)) }, mutable: true }) -> Externref`.
5717
+ const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5);
5718
+ return ret;
2944
5719
  },
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;
5720
+ __wbindgen_cast_0000000000000003: function(arg0) {
5721
+ // Cast intrinsic for `F64 -> Externref`.
5722
+ const ret = arg0;
2950
5723
  return ret;
2951
- }, arguments); },
2952
- __wbg_static_accessor_GLOBAL_4ef717fb391d88b7: function() {
2953
- const ret = typeof global === 'undefined' ? null : global;
2954
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
2955
5724
  },
2956
- __wbg_static_accessor_GLOBAL_THIS_8d1badc68b5a74f4: function() {
2957
- const ret = typeof globalThis === 'undefined' ? null : globalThis;
2958
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
5725
+ __wbindgen_cast_0000000000000004: function(arg0, arg1) {
5726
+ // Cast intrinsic for `Ref(Slice(F32)) -> NamedExternref("Float32Array")`.
5727
+ const ret = getArrayF32FromWasm0(arg0, arg1);
5728
+ return ret;
2959
5729
  },
2960
- __wbg_static_accessor_SELF_146583524fe1469b: function() {
2961
- const ret = typeof self === 'undefined' ? null : self;
2962
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
5730
+ __wbindgen_cast_0000000000000005: function(arg0, arg1) {
5731
+ // Cast intrinsic for `Ref(Slice(I16)) -> NamedExternref("Int16Array")`.
5732
+ const ret = getArrayI16FromWasm0(arg0, arg1);
5733
+ return ret;
2963
5734
  },
2964
- __wbg_static_accessor_WINDOW_f2829a2234d7819e: function() {
2965
- const ret = typeof window === 'undefined' ? null : window;
2966
- return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
5735
+ __wbindgen_cast_0000000000000006: function(arg0, arg1) {
5736
+ // Cast intrinsic for `Ref(Slice(I32)) -> NamedExternref("Int32Array")`.
5737
+ const ret = getArrayI32FromWasm0(arg0, arg1);
5738
+ return ret;
2967
5739
  },
2968
- __wbg_subarray_3ed232c8a6baee09: function(arg0, arg1, arg2) {
2969
- const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
5740
+ __wbindgen_cast_0000000000000007: function(arg0, arg1) {
5741
+ // Cast intrinsic for `Ref(Slice(I8)) -> NamedExternref("Int8Array")`.
5742
+ const ret = getArrayI8FromWasm0(arg0, arg1);
2970
5743
  return ret;
2971
5744
  },
2972
- __wbg_versions_276b2795b1c6a219: function(arg0) {
2973
- const ret = arg0.versions;
5745
+ __wbindgen_cast_0000000000000008: function(arg0, arg1) {
5746
+ // Cast intrinsic for `Ref(Slice(U16)) -> NamedExternref("Uint16Array")`.
5747
+ const ret = getArrayU16FromWasm0(arg0, arg1);
2974
5748
  return ret;
2975
5749
  },
2976
- __wbindgen_cast_0000000000000001: function(arg0, arg1) {
5750
+ __wbindgen_cast_0000000000000009: function(arg0, arg1) {
5751
+ // Cast intrinsic for `Ref(Slice(U32)) -> NamedExternref("Uint32Array")`.
5752
+ const ret = getArrayU32FromWasm0(arg0, arg1);
5753
+ return ret;
5754
+ },
5755
+ __wbindgen_cast_000000000000000a: function(arg0, arg1) {
2977
5756
  // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
2978
5757
  const ret = getArrayU8FromWasm0(arg0, arg1);
2979
5758
  return ret;
2980
5759
  },
2981
- __wbindgen_cast_0000000000000002: function(arg0, arg1) {
5760
+ __wbindgen_cast_000000000000000b: function(arg0, arg1) {
2982
5761
  // Cast intrinsic for `Ref(String) -> Externref`.
2983
5762
  const ret = getStringFromWasm0(arg0, arg1);
2984
5763
  return ret;
@@ -2999,15 +5778,119 @@ function __wbg_get_imports() {
2999
5778
  };
3000
5779
  }
3001
5780
 
5781
+ function wasm_bindgen__convert__closures_____invoke__h1592ff3f91e1224b(arg0, arg1, arg2) {
5782
+ wasm.wasm_bindgen__convert__closures_____invoke__h1592ff3f91e1224b(arg0, arg1, arg2);
5783
+ }
5784
+
5785
+ function wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2) {
5786
+ const ret = wasm.wasm_bindgen__convert__closures_____invoke__h63cbec796bb507b5(arg0, arg1, arg2);
5787
+ if (ret[1]) {
5788
+ throw takeFromExternrefTable0(ret[0]);
5789
+ }
5790
+ }
5791
+
5792
+ function wasm_bindgen__convert__closures_____invoke__h1149b643047c36f1(arg0, arg1, arg2, arg3) {
5793
+ wasm.wasm_bindgen__convert__closures_____invoke__h1149b643047c36f1(arg0, arg1, arg2, arg3);
5794
+ }
5795
+
5796
+
5797
+ const __wbindgen_enum_GpuAddressMode = ["clamp-to-edge", "repeat", "mirror-repeat"];
5798
+
5799
+
5800
+ 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"];
5801
+
5802
+
5803
+ const __wbindgen_enum_GpuBlendOperation = ["add", "subtract", "reverse-subtract", "min", "max"];
5804
+
5805
+
5806
+ const __wbindgen_enum_GpuBufferBindingType = ["uniform", "storage", "read-only-storage"];
5807
+
5808
+
5809
+ const __wbindgen_enum_GpuCanvasAlphaMode = ["opaque", "premultiplied"];
5810
+
5811
+
5812
+ const __wbindgen_enum_GpuCompareFunction = ["never", "less", "equal", "less-equal", "greater", "not-equal", "greater-equal", "always"];
5813
+
5814
+
5815
+ const __wbindgen_enum_GpuCullMode = ["none", "front", "back"];
5816
+
5817
+
5818
+ const __wbindgen_enum_GpuErrorFilter = ["validation", "out-of-memory", "internal"];
5819
+
5820
+
5821
+ const __wbindgen_enum_GpuFilterMode = ["nearest", "linear"];
5822
+
5823
+
5824
+ const __wbindgen_enum_GpuFrontFace = ["ccw", "cw"];
5825
+
5826
+
5827
+ const __wbindgen_enum_GpuIndexFormat = ["uint16", "uint32"];
5828
+
5829
+
5830
+ const __wbindgen_enum_GpuLoadOp = ["load", "clear"];
5831
+
5832
+
5833
+ const __wbindgen_enum_GpuMipmapFilterMode = ["nearest", "linear"];
5834
+
5835
+
5836
+ const __wbindgen_enum_GpuPowerPreference = ["low-power", "high-performance"];
5837
+
5838
+
5839
+ const __wbindgen_enum_GpuPrimitiveTopology = ["point-list", "line-list", "line-strip", "triangle-list", "triangle-strip"];
5840
+
5841
+
5842
+ const __wbindgen_enum_GpuQueryType = ["occlusion", "timestamp"];
5843
+
5844
+
5845
+ const __wbindgen_enum_GpuSamplerBindingType = ["filtering", "non-filtering", "comparison"];
5846
+
5847
+
5848
+ const __wbindgen_enum_GpuStencilOperation = ["keep", "zero", "replace", "invert", "increment-clamp", "decrement-clamp", "increment-wrap", "decrement-wrap"];
5849
+
5850
+
5851
+ const __wbindgen_enum_GpuStorageTextureAccess = ["write-only", "read-only", "read-write"];
5852
+
5853
+
5854
+ const __wbindgen_enum_GpuStoreOp = ["store", "discard"];
5855
+
5856
+
5857
+ const __wbindgen_enum_GpuTextureAspect = ["all", "stencil-only", "depth-only"];
5858
+
5859
+
5860
+ const __wbindgen_enum_GpuTextureDimension = ["1d", "2d", "3d"];
5861
+
5862
+
5863
+ 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"];
5864
+
5865
+
5866
+ const __wbindgen_enum_GpuTextureSampleType = ["float", "unfilterable-float", "depth", "sint", "uint"];
5867
+
5868
+
5869
+ const __wbindgen_enum_GpuTextureViewDimension = ["1d", "2d", "2d-array", "cube", "cube-array", "3d"];
5870
+
5871
+
5872
+ 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"];
5873
+
5874
+
5875
+ const __wbindgen_enum_GpuVertexStepMode = ["vertex", "instance"];
5876
+ const Canvas3DFinalization = (typeof FinalizationRegistry === 'undefined')
5877
+ ? { register: () => {}, unregister: () => {} }
5878
+ : new FinalizationRegistry(ptr => wasm.__wbg_canvas3d_free(ptr, 1));
3002
5879
  const CredentialVaultFinalization = (typeof FinalizationRegistry === 'undefined')
3003
5880
  ? { register: () => {}, unregister: () => {} }
3004
5881
  : new FinalizationRegistry(ptr => wasm.__wbg_credentialvault_free(ptr, 1));
5882
+ const GpuHostFinalization = (typeof FinalizationRegistry === 'undefined')
5883
+ ? { register: () => {}, unregister: () => {} }
5884
+ : new FinalizationRegistry(ptr => wasm.__wbg_gpuhost_free(ptr, 1));
3005
5885
  const KernelFinalization = (typeof FinalizationRegistry === 'undefined')
3006
5886
  ? { register: () => {}, unregister: () => {} }
3007
5887
  : new FinalizationRegistry(ptr => wasm.__wbg_kernel_free(ptr, 1));
3008
5888
  const MemoryStoreFinalization = (typeof FinalizationRegistry === 'undefined')
3009
5889
  ? { register: () => {}, unregister: () => {} }
3010
5890
  : new FinalizationRegistry(ptr => wasm.__wbg_memorystore_free(ptr, 1));
5891
+ const SceneCanvasFinalization = (typeof FinalizationRegistry === 'undefined')
5892
+ ? { register: () => {}, unregister: () => {} }
5893
+ : new FinalizationRegistry(ptr => wasm.__wbg_scenecanvas_free(ptr, 1));
3011
5894
  const ServerFinalization = (typeof FinalizationRegistry === 'undefined')
3012
5895
  ? { register: () => {}, unregister: () => {} }
3013
5896
  : new FinalizationRegistry(ptr => wasm.__wbg_server_free(ptr, 1));
@@ -3018,15 +5901,176 @@ function addToExternrefTable0(obj) {
3018
5901
  return idx;
3019
5902
  }
3020
5903
 
5904
+ function _assertClass(instance, klass) {
5905
+ if (!(instance instanceof klass)) {
5906
+ throw new Error(`expected instance of ${klass.name}`);
5907
+ }
5908
+ }
5909
+
5910
+ const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
5911
+ ? { register: () => {}, unregister: () => {} }
5912
+ : new FinalizationRegistry(state => wasm.__wbindgen_destroy_closure(state.a, state.b));
5913
+
5914
+ function debugString(val) {
5915
+ // primitive types
5916
+ const type = typeof val;
5917
+ if (type == 'number' || type == 'boolean' || val == null) {
5918
+ return `${val}`;
5919
+ }
5920
+ if (type == 'string') {
5921
+ return `"${val}"`;
5922
+ }
5923
+ if (type == 'symbol') {
5924
+ const description = val.description;
5925
+ if (description == null) {
5926
+ return 'Symbol';
5927
+ } else {
5928
+ return `Symbol(${description})`;
5929
+ }
5930
+ }
5931
+ if (type == 'function') {
5932
+ const name = val.name;
5933
+ if (typeof name == 'string' && name.length > 0) {
5934
+ return `Function(${name})`;
5935
+ } else {
5936
+ return 'Function';
5937
+ }
5938
+ }
5939
+ // objects
5940
+ if (Array.isArray(val)) {
5941
+ const length = val.length;
5942
+ let debug = '[';
5943
+ if (length > 0) {
5944
+ debug += debugString(val[0]);
5945
+ }
5946
+ for(let i = 1; i < length; i++) {
5947
+ debug += ', ' + debugString(val[i]);
5948
+ }
5949
+ debug += ']';
5950
+ return debug;
5951
+ }
5952
+ // Test for built-in
5953
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
5954
+ let className;
5955
+ if (builtInMatches && builtInMatches.length > 1) {
5956
+ className = builtInMatches[1];
5957
+ } else {
5958
+ // Failed to match the standard '[object ClassName]'
5959
+ return toString.call(val);
5960
+ }
5961
+ if (className == 'Object') {
5962
+ // we're a user defined class or Object
5963
+ // JSON.stringify avoids problems with cycles, and is generally much
5964
+ // easier than looping through ownProperties of `val`.
5965
+ try {
5966
+ return 'Object(' + JSON.stringify(val) + ')';
5967
+ } catch (_) {
5968
+ return 'Object';
5969
+ }
5970
+ }
5971
+ // errors
5972
+ if (val instanceof Error) {
5973
+ return `${val.name}: ${val.message}\n${val.stack}`;
5974
+ }
5975
+ // TODO we could test for more things here, like `Set`s and `Map`s.
5976
+ return className;
5977
+ }
5978
+
5979
+ function getArrayF32FromWasm0(ptr, len) {
5980
+ ptr = ptr >>> 0;
5981
+ return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
5982
+ }
5983
+
5984
+ function getArrayI16FromWasm0(ptr, len) {
5985
+ ptr = ptr >>> 0;
5986
+ return getInt16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
5987
+ }
5988
+
5989
+ function getArrayI32FromWasm0(ptr, len) {
5990
+ ptr = ptr >>> 0;
5991
+ return getInt32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
5992
+ }
5993
+
5994
+ function getArrayI8FromWasm0(ptr, len) {
5995
+ ptr = ptr >>> 0;
5996
+ return getInt8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
5997
+ }
5998
+
5999
+ function getArrayU16FromWasm0(ptr, len) {
6000
+ ptr = ptr >>> 0;
6001
+ return getUint16ArrayMemory0().subarray(ptr / 2, ptr / 2 + len);
6002
+ }
6003
+
6004
+ function getArrayU32FromWasm0(ptr, len) {
6005
+ ptr = ptr >>> 0;
6006
+ return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
6007
+ }
6008
+
3021
6009
  function getArrayU8FromWasm0(ptr, len) {
3022
6010
  ptr = ptr >>> 0;
3023
6011
  return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
3024
6012
  }
3025
6013
 
6014
+ let cachedDataViewMemory0 = null;
6015
+ function getDataViewMemory0() {
6016
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
6017
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
6018
+ }
6019
+ return cachedDataViewMemory0;
6020
+ }
6021
+
6022
+ let cachedFloat32ArrayMemory0 = null;
6023
+ function getFloat32ArrayMemory0() {
6024
+ if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
6025
+ cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
6026
+ }
6027
+ return cachedFloat32ArrayMemory0;
6028
+ }
6029
+
6030
+ let cachedInt16ArrayMemory0 = null;
6031
+ function getInt16ArrayMemory0() {
6032
+ if (cachedInt16ArrayMemory0 === null || cachedInt16ArrayMemory0.byteLength === 0) {
6033
+ cachedInt16ArrayMemory0 = new Int16Array(wasm.memory.buffer);
6034
+ }
6035
+ return cachedInt16ArrayMemory0;
6036
+ }
6037
+
6038
+ let cachedInt32ArrayMemory0 = null;
6039
+ function getInt32ArrayMemory0() {
6040
+ if (cachedInt32ArrayMemory0 === null || cachedInt32ArrayMemory0.byteLength === 0) {
6041
+ cachedInt32ArrayMemory0 = new Int32Array(wasm.memory.buffer);
6042
+ }
6043
+ return cachedInt32ArrayMemory0;
6044
+ }
6045
+
6046
+ let cachedInt8ArrayMemory0 = null;
6047
+ function getInt8ArrayMemory0() {
6048
+ if (cachedInt8ArrayMemory0 === null || cachedInt8ArrayMemory0.byteLength === 0) {
6049
+ cachedInt8ArrayMemory0 = new Int8Array(wasm.memory.buffer);
6050
+ }
6051
+ return cachedInt8ArrayMemory0;
6052
+ }
6053
+
3026
6054
  function getStringFromWasm0(ptr, len) {
3027
6055
  return decodeText(ptr >>> 0, len);
3028
6056
  }
3029
6057
 
6058
+ let cachedUint16ArrayMemory0 = null;
6059
+ function getUint16ArrayMemory0() {
6060
+ if (cachedUint16ArrayMemory0 === null || cachedUint16ArrayMemory0.byteLength === 0) {
6061
+ cachedUint16ArrayMemory0 = new Uint16Array(wasm.memory.buffer);
6062
+ }
6063
+ return cachedUint16ArrayMemory0;
6064
+ }
6065
+
6066
+ let cachedUint32ArrayMemory0 = null;
6067
+ function getUint32ArrayMemory0() {
6068
+ if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
6069
+ cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
6070
+ }
6071
+ return cachedUint32ArrayMemory0;
6072
+ }
6073
+
3030
6074
  let cachedUint8ArrayMemory0 = null;
3031
6075
  function getUint8ArrayMemory0() {
3032
6076
  if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
@@ -3048,6 +6092,34 @@ function isLikeNone(x) {
3048
6092
  return x === undefined || x === null;
3049
6093
  }
3050
6094
 
6095
+ function makeMutClosure(arg0, arg1, f) {
6096
+ const state = { a: arg0, b: arg1, cnt: 1 };
6097
+ const real = (...args) => {
6098
+
6099
+ // First up with a closure we increment the internal reference
6100
+ // count. This ensures that the Rust closure environment won't
6101
+ // be deallocated while we're invoking it.
6102
+ state.cnt++;
6103
+ const a = state.a;
6104
+ state.a = 0;
6105
+ try {
6106
+ return f(a, state.b, ...args);
6107
+ } finally {
6108
+ state.a = a;
6109
+ real._wbg_cb_unref();
6110
+ }
6111
+ };
6112
+ real._wbg_cb_unref = () => {
6113
+ if (--state.cnt === 0) {
6114
+ wasm.__wbindgen_destroy_closure(state.a, state.b);
6115
+ state.a = 0;
6116
+ CLOSURE_DTORS.unregister(state);
6117
+ }
6118
+ };
6119
+ CLOSURE_DTORS.register(real, state, state);
6120
+ return real;
6121
+ }
6122
+
3051
6123
  function passStringToWasm0(arg, malloc, realloc) {
3052
6124
  if (realloc === undefined) {
3053
6125
  const buf = cachedTextEncoder.encode(arg);
@@ -3125,6 +6197,13 @@ function __wbg_finalize_init(instance, module) {
3125
6197
  wasmInstance = instance;
3126
6198
  wasm = instance.exports;
3127
6199
  wasmModule = module;
6200
+ cachedDataViewMemory0 = null;
6201
+ cachedFloat32ArrayMemory0 = null;
6202
+ cachedInt16ArrayMemory0 = null;
6203
+ cachedInt32ArrayMemory0 = null;
6204
+ cachedInt8ArrayMemory0 = null;
6205
+ cachedUint16ArrayMemory0 = null;
6206
+ cachedUint32ArrayMemory0 = null;
3128
6207
  cachedUint8ArrayMemory0 = null;
3129
6208
  wasm.__wbindgen_start();
3130
6209
  return wasm;