windmill-parser-wasm-ts 1.438.2 → 1.486.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -4,7 +4,7 @@
4
4
  "collaborators": [
5
5
  "Ruben Fiszel <ruben@windmill.dev>"
6
6
  ],
7
- "version": "1.438.2",
7
+ "version": "1.486.1",
8
8
  "files": [
9
9
  "windmill_parser_wasm_bg.wasm",
10
10
  "windmill_parser_wasm.js",
@@ -15,4 +15,4 @@
15
15
  "sideEffects": [
16
16
  "./snippets/*"
17
17
  ]
18
- }
18
+ }
@@ -1,34 +1,23 @@
1
1
  /* tslint:disable */
2
2
  /* eslint-disable */
3
- /**
4
- * @param {string} code
5
- * @param {string | undefined} [main_override]
6
- * @returns {string}
7
- */
8
- export function parse_deno(code: string, main_override?: string): string;
9
- /**
10
- * @param {string} code
11
- * @returns {string}
12
- */
3
+ export function parse_deno(code: string, main_override?: string | null): string;
13
4
  export function parse_outputs(code: string): string;
14
- /**
15
- * @param {string} code
16
- * @returns {string}
17
- */
18
5
  export function parse_ts_imports(code: string): string;
19
6
 
20
7
  export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
21
8
 
22
9
  export interface InitOutput {
23
10
  readonly memory: WebAssembly.Memory;
24
- readonly parse_deno: (a: number, b: number, c: number, d: number, e: number) => void;
25
- readonly parse_outputs: (a: number, b: number, c: number) => void;
26
- readonly parse_ts_imports: (a: number, b: number, c: number) => void;
11
+ readonly parse_deno: (a: number, b: number, c: number, d: number) => [number, number];
12
+ readonly parse_outputs: (a: number, b: number) => [number, number];
13
+ readonly parse_ts_imports: (a: number, b: number) => [number, number];
14
+ readonly __wbindgen_exn_store: (a: number) => void;
15
+ readonly __externref_table_alloc: () => number;
16
+ readonly __wbindgen_export_2: WebAssembly.Table;
27
17
  readonly __wbindgen_malloc: (a: number, b: number) => number;
28
18
  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
29
- readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
30
19
  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
31
- readonly __wbindgen_exn_store: (a: number) => void;
20
+ readonly __wbindgen_start: () => void;
32
21
  }
33
22
 
34
23
  export type SyncInitInput = BufferSource | WebAssembly.Module;
@@ -36,18 +25,18 @@ export type SyncInitInput = BufferSource | WebAssembly.Module;
36
25
  * Instantiates the given `module`, which can either be bytes or
37
26
  * a precompiled `WebAssembly.Module`.
38
27
  *
39
- * @param {SyncInitInput} module
28
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
40
29
  *
41
30
  * @returns {InitOutput}
42
31
  */
43
- export function initSync(module: SyncInitInput): InitOutput;
32
+ export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
44
33
 
45
34
  /**
46
35
  * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
47
36
  * for everything else, calls `WebAssembly.instantiate` directly.
48
37
  *
49
- * @param {InitInput | Promise<InitInput>} module_or_path
38
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
50
39
  *
51
40
  * @returns {Promise<InitOutput>}
52
41
  */
53
- export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
42
+ export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;
@@ -1,137 +1,49 @@
1
1
  let wasm;
2
2
 
3
- const heap = new Array(128).fill(undefined);
4
-
5
- heap.push(undefined, null, true, false);
6
-
7
- function getObject(idx) { return heap[idx]; }
8
-
9
- let heap_next = heap.length;
10
-
11
- function dropObject(idx) {
12
- if (idx < 132) return;
13
- heap[idx] = heap_next;
14
- heap_next = idx;
15
- }
16
-
17
- function takeObject(idx) {
18
- const ret = getObject(idx);
19
- dropObject(idx);
20
- return ret;
3
+ function addToExternrefTable0(obj) {
4
+ const idx = wasm.__externref_table_alloc();
5
+ wasm.__wbindgen_export_2.set(idx, obj);
6
+ return idx;
21
7
  }
22
8
 
23
- function addHeapObject(obj) {
24
- if (heap_next === heap.length) heap.push(heap.length + 1);
25
- const idx = heap_next;
26
- heap_next = heap[idx];
27
-
28
- heap[idx] = obj;
29
- return idx;
9
+ function handleError(f, args) {
10
+ try {
11
+ return f.apply(this, args);
12
+ } catch (e) {
13
+ const idx = addToExternrefTable0(e);
14
+ wasm.__wbindgen_exn_store(idx);
15
+ }
30
16
  }
31
17
 
32
18
  const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
33
19
 
34
20
  if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
35
21
 
36
- let cachedUint8Memory0 = null;
22
+ let cachedUint8ArrayMemory0 = null;
37
23
 
38
- function getUint8Memory0() {
39
- if (cachedUint8Memory0 === null || cachedUint8Memory0.byteLength === 0) {
40
- cachedUint8Memory0 = new Uint8Array(wasm.memory.buffer);
24
+ function getUint8ArrayMemory0() {
25
+ if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
26
+ cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
41
27
  }
42
- return cachedUint8Memory0;
28
+ return cachedUint8ArrayMemory0;
43
29
  }
44
30
 
45
31
  function getStringFromWasm0(ptr, len) {
46
32
  ptr = ptr >>> 0;
47
- return cachedTextDecoder.decode(getUint8Memory0().subarray(ptr, ptr + len));
33
+ return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
48
34
  }
49
35
 
50
36
  function isLikeNone(x) {
51
37
  return x === undefined || x === null;
52
38
  }
53
39
 
54
- let cachedFloat64Memory0 = null;
55
-
56
- function getFloat64Memory0() {
57
- if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
58
- cachedFloat64Memory0 = new Float64Array(wasm.memory.buffer);
59
- }
60
- return cachedFloat64Memory0;
61
- }
62
-
63
- let cachedInt32Memory0 = null;
40
+ let cachedDataViewMemory0 = null;
64
41
 
65
- function getInt32Memory0() {
66
- if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
67
- cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
42
+ function getDataViewMemory0() {
43
+ if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
44
+ cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
68
45
  }
69
- return cachedInt32Memory0;
70
- }
71
-
72
- let WASM_VECTOR_LEN = 0;
73
-
74
- const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
75
-
76
- const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
77
- ? function (arg, view) {
78
- return cachedTextEncoder.encodeInto(arg, view);
79
- }
80
- : function (arg, view) {
81
- const buf = cachedTextEncoder.encode(arg);
82
- view.set(buf);
83
- return {
84
- read: arg.length,
85
- written: buf.length
86
- };
87
- });
88
-
89
- function passStringToWasm0(arg, malloc, realloc) {
90
-
91
- if (realloc === undefined) {
92
- const buf = cachedTextEncoder.encode(arg);
93
- const ptr = malloc(buf.length, 1) >>> 0;
94
- getUint8Memory0().subarray(ptr, ptr + buf.length).set(buf);
95
- WASM_VECTOR_LEN = buf.length;
96
- return ptr;
97
- }
98
-
99
- let len = arg.length;
100
- let ptr = malloc(len, 1) >>> 0;
101
-
102
- const mem = getUint8Memory0();
103
-
104
- let offset = 0;
105
-
106
- for (; offset < len; offset++) {
107
- const code = arg.charCodeAt(offset);
108
- if (code > 0x7F) break;
109
- mem[ptr + offset] = code;
110
- }
111
-
112
- if (offset !== len) {
113
- if (offset !== 0) {
114
- arg = arg.slice(offset);
115
- }
116
- ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
117
- const view = getUint8Memory0().subarray(ptr + offset, ptr + len);
118
- const ret = encodeString(arg, view);
119
-
120
- offset += ret.written;
121
- ptr = realloc(ptr, len, offset, 1) >>> 0;
122
- }
123
-
124
- WASM_VECTOR_LEN = offset;
125
- return ptr;
126
- }
127
-
128
- let cachedBigInt64Memory0 = null;
129
-
130
- function getBigInt64Memory0() {
131
- if (cachedBigInt64Memory0 === null || cachedBigInt64Memory0.byteLength === 0) {
132
- cachedBigInt64Memory0 = new BigInt64Array(wasm.memory.buffer);
133
- }
134
- return cachedBigInt64Memory0;
46
+ return cachedDataViewMemory0;
135
47
  }
136
48
 
137
49
  function debugString(val) {
@@ -175,7 +87,7 @@ function debugString(val) {
175
87
  // Test for built-in
176
88
  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
177
89
  let className;
178
- if (builtInMatches.length > 1) {
90
+ if (builtInMatches && builtInMatches.length > 1) {
179
91
  className = builtInMatches[1];
180
92
  } else {
181
93
  // Failed to match the standard '[object ClassName]'
@@ -198,86 +110,122 @@ function debugString(val) {
198
110
  // TODO we could test for more things here, like `Set`s and `Map`s.
199
111
  return className;
200
112
  }
113
+
114
+ let WASM_VECTOR_LEN = 0;
115
+
116
+ const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
117
+
118
+ const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
119
+ ? function (arg, view) {
120
+ return cachedTextEncoder.encodeInto(arg, view);
121
+ }
122
+ : function (arg, view) {
123
+ const buf = cachedTextEncoder.encode(arg);
124
+ view.set(buf);
125
+ return {
126
+ read: arg.length,
127
+ written: buf.length
128
+ };
129
+ });
130
+
131
+ function passStringToWasm0(arg, malloc, realloc) {
132
+
133
+ if (realloc === undefined) {
134
+ const buf = cachedTextEncoder.encode(arg);
135
+ const ptr = malloc(buf.length, 1) >>> 0;
136
+ getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
137
+ WASM_VECTOR_LEN = buf.length;
138
+ return ptr;
139
+ }
140
+
141
+ let len = arg.length;
142
+ let ptr = malloc(len, 1) >>> 0;
143
+
144
+ const mem = getUint8ArrayMemory0();
145
+
146
+ let offset = 0;
147
+
148
+ for (; offset < len; offset++) {
149
+ const code = arg.charCodeAt(offset);
150
+ if (code > 0x7F) break;
151
+ mem[ptr + offset] = code;
152
+ }
153
+
154
+ if (offset !== len) {
155
+ if (offset !== 0) {
156
+ arg = arg.slice(offset);
157
+ }
158
+ ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
159
+ const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
160
+ const ret = encodeString(arg, view);
161
+
162
+ offset += ret.written;
163
+ ptr = realloc(ptr, len, offset, 1) >>> 0;
164
+ }
165
+
166
+ WASM_VECTOR_LEN = offset;
167
+ return ptr;
168
+ }
201
169
  /**
202
- * @param {string} code
203
- * @param {string | undefined} [main_override]
204
- * @returns {string}
205
- */
170
+ * @param {string} code
171
+ * @param {string | null} [main_override]
172
+ * @returns {string}
173
+ */
206
174
  export function parse_deno(code, main_override) {
207
175
  let deferred3_0;
208
176
  let deferred3_1;
209
177
  try {
210
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
211
178
  const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
212
179
  const len0 = WASM_VECTOR_LEN;
213
180
  var ptr1 = isLikeNone(main_override) ? 0 : passStringToWasm0(main_override, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
214
181
  var len1 = WASM_VECTOR_LEN;
215
- wasm.parse_deno(retptr, ptr0, len0, ptr1, len1);
216
- var r0 = getInt32Memory0()[retptr / 4 + 0];
217
- var r1 = getInt32Memory0()[retptr / 4 + 1];
218
- deferred3_0 = r0;
219
- deferred3_1 = r1;
220
- return getStringFromWasm0(r0, r1);
182
+ const ret = wasm.parse_deno(ptr0, len0, ptr1, len1);
183
+ deferred3_0 = ret[0];
184
+ deferred3_1 = ret[1];
185
+ return getStringFromWasm0(ret[0], ret[1]);
221
186
  } finally {
222
- wasm.__wbindgen_add_to_stack_pointer(16);
223
187
  wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
224
188
  }
225
189
  }
226
190
 
227
191
  /**
228
- * @param {string} code
229
- * @returns {string}
230
- */
192
+ * @param {string} code
193
+ * @returns {string}
194
+ */
231
195
  export function parse_outputs(code) {
232
196
  let deferred2_0;
233
197
  let deferred2_1;
234
198
  try {
235
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
236
199
  const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
237
200
  const len0 = WASM_VECTOR_LEN;
238
- wasm.parse_outputs(retptr, ptr0, len0);
239
- var r0 = getInt32Memory0()[retptr / 4 + 0];
240
- var r1 = getInt32Memory0()[retptr / 4 + 1];
241
- deferred2_0 = r0;
242
- deferred2_1 = r1;
243
- return getStringFromWasm0(r0, r1);
201
+ const ret = wasm.parse_outputs(ptr0, len0);
202
+ deferred2_0 = ret[0];
203
+ deferred2_1 = ret[1];
204
+ return getStringFromWasm0(ret[0], ret[1]);
244
205
  } finally {
245
- wasm.__wbindgen_add_to_stack_pointer(16);
246
206
  wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
247
207
  }
248
208
  }
249
209
 
250
210
  /**
251
- * @param {string} code
252
- * @returns {string}
253
- */
211
+ * @param {string} code
212
+ * @returns {string}
213
+ */
254
214
  export function parse_ts_imports(code) {
255
215
  let deferred2_0;
256
216
  let deferred2_1;
257
217
  try {
258
- const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
259
218
  const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
260
219
  const len0 = WASM_VECTOR_LEN;
261
- wasm.parse_ts_imports(retptr, ptr0, len0);
262
- var r0 = getInt32Memory0()[retptr / 4 + 0];
263
- var r1 = getInt32Memory0()[retptr / 4 + 1];
264
- deferred2_0 = r0;
265
- deferred2_1 = r1;
266
- return getStringFromWasm0(r0, r1);
220
+ const ret = wasm.parse_ts_imports(ptr0, len0);
221
+ deferred2_0 = ret[0];
222
+ deferred2_1 = ret[1];
223
+ return getStringFromWasm0(ret[0], ret[1]);
267
224
  } finally {
268
- wasm.__wbindgen_add_to_stack_pointer(16);
269
225
  wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
270
226
  }
271
227
  }
272
228
 
273
- function handleError(f, args) {
274
- try {
275
- return f.apply(this, args);
276
- } catch (e) {
277
- wasm.__wbindgen_exn_store(addHeapObject(e));
278
- }
279
- }
280
-
281
229
  async function __wbg_load(module, imports) {
282
230
  if (typeof Response === 'function' && module instanceof Response) {
283
231
  if (typeof WebAssembly.instantiateStreaming === 'function') {
@@ -286,7 +234,7 @@ async function __wbg_load(module, imports) {
286
234
 
287
235
  } catch (e) {
288
236
  if (module.headers.get('Content-Type') != 'application/wasm') {
289
- console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
237
+ console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
290
238
 
291
239
  } else {
292
240
  throw e;
@@ -312,205 +260,220 @@ async function __wbg_load(module, imports) {
312
260
  function __wbg_get_imports() {
313
261
  const imports = {};
314
262
  imports.wbg = {};
315
- imports.wbg.__wbg_get_bd8e338fbd5f5cc8 = function(arg0, arg1) {
316
- const ret = getObject(arg0)[arg1 >>> 0];
317
- return addHeapObject(ret);
318
- };
319
- imports.wbg.__wbg_length_cd7af8117672b8b8 = function(arg0) {
320
- const ret = getObject(arg0).length;
321
- return ret;
322
- };
323
- imports.wbg.__wbindgen_is_object = function(arg0) {
324
- const val = getObject(arg0);
325
- const ret = typeof(val) === 'object' && val !== null;
263
+ imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
264
+ const ret = arg0.buffer;
326
265
  return ret;
327
266
  };
328
- imports.wbg.__wbg_next_40fc327bfc8770e6 = function(arg0) {
329
- const ret = getObject(arg0).next;
330
- return addHeapObject(ret);
331
- };
332
- imports.wbg.__wbindgen_is_function = function(arg0) {
333
- const ret = typeof(getObject(arg0)) === 'function';
267
+ imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
268
+ const ret = arg0.call(arg1);
334
269
  return ret;
335
- };
336
- imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
337
- takeObject(arg0);
338
- };
339
- imports.wbg.__wbg_next_196c84450b364254 = function() { return handleError(function (arg0) {
340
- const ret = getObject(arg0).next();
341
- return addHeapObject(ret);
342
270
  }, arguments) };
343
- imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
344
- const ret = getObject(arg0).done;
271
+ imports.wbg.__wbg_done_769e5ede4b31c67b = function(arg0) {
272
+ const ret = arg0.done;
345
273
  return ret;
346
274
  };
347
- imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
348
- const ret = getObject(arg0).value;
349
- return addHeapObject(ret);
275
+ imports.wbg.__wbg_entries_3265d4158b33e5dc = function(arg0) {
276
+ const ret = Object.entries(arg0);
277
+ return ret;
350
278
  };
351
- imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
352
- const ret = Symbol.iterator;
353
- return addHeapObject(ret);
279
+ imports.wbg.__wbg_eval_71dda4bf7abd54ec = function(arg0, arg1) {
280
+ const ret = eval(getStringFromWasm0(arg0, arg1));
281
+ return ret;
354
282
  };
355
- imports.wbg.__wbg_get_e3c254076557e348 = function() { return handleError(function (arg0, arg1) {
356
- const ret = Reflect.get(getObject(arg0), getObject(arg1));
357
- return addHeapObject(ret);
358
- }, arguments) };
359
- imports.wbg.__wbg_call_27c0f87801dedf93 = function() { return handleError(function (arg0, arg1) {
360
- const ret = getObject(arg0).call(getObject(arg1));
361
- return addHeapObject(ret);
283
+ imports.wbg.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
284
+ const ret = Reflect.get(arg0, arg1);
285
+ return ret;
362
286
  }, arguments) };
363
- imports.wbg.__wbg_isArray_2ab64d95e09ea0ae = function(arg0) {
364
- const ret = Array.isArray(getObject(arg0));
287
+ imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
288
+ const ret = arg0[arg1 >>> 0];
365
289
  return ret;
366
290
  };
367
- imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
291
+ imports.wbg.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
368
292
  let result;
369
293
  try {
370
- result = getObject(arg0) instanceof ArrayBuffer;
294
+ result = arg0 instanceof ArrayBuffer;
371
295
  } catch (_) {
372
296
  result = false;
373
297
  }
374
298
  const ret = result;
375
299
  return ret;
376
300
  };
377
- imports.wbg.__wbg_instanceof_Map_87917e0a7aaf4012 = function(arg0) {
301
+ imports.wbg.__wbg_instanceof_Map_f3469ce2244d2430 = function(arg0) {
378
302
  let result;
379
303
  try {
380
- result = getObject(arg0) instanceof Map;
304
+ result = arg0 instanceof Map;
381
305
  } catch (_) {
382
306
  result = false;
383
307
  }
384
308
  const ret = result;
385
309
  return ret;
386
310
  };
387
- imports.wbg.__wbg_isSafeInteger_f7b04ef02296c4d2 = function(arg0) {
388
- const ret = Number.isSafeInteger(getObject(arg0));
311
+ imports.wbg.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) {
312
+ let result;
313
+ try {
314
+ result = arg0 instanceof Uint8Array;
315
+ } catch (_) {
316
+ result = false;
317
+ }
318
+ const ret = result;
389
319
  return ret;
390
320
  };
391
- imports.wbg.__wbg_entries_95cc2c823b285a09 = function(arg0) {
392
- const ret = Object.entries(getObject(arg0));
393
- return addHeapObject(ret);
394
- };
395
- imports.wbg.__wbindgen_memory = function() {
396
- const ret = wasm.memory;
397
- return addHeapObject(ret);
321
+ imports.wbg.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
322
+ const ret = Array.isArray(arg0);
323
+ return ret;
398
324
  };
399
- imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
400
- const ret = getObject(arg0).buffer;
401
- return addHeapObject(ret);
325
+ imports.wbg.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) {
326
+ const ret = Number.isSafeInteger(arg0);
327
+ return ret;
402
328
  };
403
- imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
404
- const ret = new Uint8Array(getObject(arg0));
405
- return addHeapObject(ret);
329
+ imports.wbg.__wbg_iterator_9a24c88df860dc65 = function() {
330
+ const ret = Symbol.iterator;
331
+ return ret;
406
332
  };
407
- imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
408
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
333
+ imports.wbg.__wbg_length_a446193dc22c12f8 = function(arg0) {
334
+ const ret = arg0.length;
335
+ return ret;
409
336
  };
410
- imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
411
- const ret = getObject(arg0).length;
337
+ imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
338
+ const ret = arg0.length;
412
339
  return ret;
413
340
  };
414
- imports.wbg.__wbg_instanceof_Uint8Array_2b3bbecd033d19f6 = function(arg0) {
415
- let result;
416
- try {
417
- result = getObject(arg0) instanceof Uint8Array;
418
- } catch (_) {
419
- result = false;
420
- }
421
- const ret = result;
341
+ imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
342
+ const ret = new Uint8Array(arg0);
422
343
  return ret;
423
344
  };
424
- imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
425
- const ret = new Error(getStringFromWasm0(arg0, arg1));
426
- return addHeapObject(ret);
345
+ imports.wbg.__wbg_next_25feadfc0913fea9 = function(arg0) {
346
+ const ret = arg0.next;
347
+ return ret;
427
348
  };
428
- imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
429
- const ret = getObject(arg0) == getObject(arg1);
349
+ imports.wbg.__wbg_next_6574e1a8a62d1055 = function() { return handleError(function (arg0) {
350
+ const ret = arg0.next();
430
351
  return ret;
352
+ }, arguments) };
353
+ imports.wbg.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
354
+ arg0.set(arg1, arg2 >>> 0);
431
355
  };
432
- imports.wbg.__wbindgen_boolean_get = function(arg0) {
433
- const v = getObject(arg0);
434
- const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
356
+ imports.wbg.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
357
+ const ret = arg0.value;
435
358
  return ret;
436
359
  };
437
- imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
438
- const obj = getObject(arg1);
439
- const ret = typeof(obj) === 'number' ? obj : undefined;
440
- getFloat64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? 0 : ret;
441
- getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
360
+ imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
361
+ const ret = arg0;
362
+ return ret;
442
363
  };
443
- imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
444
- const obj = getObject(arg1);
445
- const ret = typeof(obj) === 'string' ? obj : undefined;
446
- var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
447
- var len1 = WASM_VECTOR_LEN;
448
- getInt32Memory0()[arg0 / 4 + 1] = len1;
449
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
364
+ imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
365
+ const ret = BigInt.asUintN(64, arg0);
366
+ return ret;
450
367
  };
451
368
  imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
452
- const v = getObject(arg1);
369
+ const v = arg1;
453
370
  const ret = typeof(v) === 'bigint' ? v : undefined;
454
- getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
455
- getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
371
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
372
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
373
+ };
374
+ imports.wbg.__wbindgen_boolean_get = function(arg0) {
375
+ const v = arg0;
376
+ const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
377
+ return ret;
456
378
  };
457
379
  imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
458
- const ret = debugString(getObject(arg1));
380
+ const ret = debugString(arg1);
459
381
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
460
382
  const len1 = WASM_VECTOR_LEN;
461
- getInt32Memory0()[arg0 / 4 + 1] = len1;
462
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
383
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
384
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
463
385
  };
464
- imports.wbg.__wbindgen_throw = function(arg0, arg1) {
465
- throw new Error(getStringFromWasm0(arg0, arg1));
386
+ imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
387
+ const ret = new Error(getStringFromWasm0(arg0, arg1));
388
+ return ret;
389
+ };
390
+ imports.wbg.__wbindgen_in = function(arg0, arg1) {
391
+ const ret = arg0 in arg1;
392
+ return ret;
393
+ };
394
+ imports.wbg.__wbindgen_init_externref_table = function() {
395
+ const table = wasm.__wbindgen_export_2;
396
+ const offset = table.grow(4);
397
+ table.set(0, undefined);
398
+ table.set(offset + 0, undefined);
399
+ table.set(offset + 1, null);
400
+ table.set(offset + 2, true);
401
+ table.set(offset + 3, false);
402
+ ;
466
403
  };
467
404
  imports.wbg.__wbindgen_is_bigint = function(arg0) {
468
- const ret = typeof(getObject(arg0)) === 'bigint';
405
+ const ret = typeof(arg0) === 'bigint';
469
406
  return ret;
470
407
  };
471
- imports.wbg.__wbindgen_in = function(arg0, arg1) {
472
- const ret = getObject(arg0) in getObject(arg1);
408
+ imports.wbg.__wbindgen_is_function = function(arg0) {
409
+ const ret = typeof(arg0) === 'function';
473
410
  return ret;
474
411
  };
475
- imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
476
- const ret = arg0;
477
- return addHeapObject(ret);
412
+ imports.wbg.__wbindgen_is_object = function(arg0) {
413
+ const val = arg0;
414
+ const ret = typeof(val) === 'object' && val !== null;
415
+ return ret;
478
416
  };
479
417
  imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
480
- const ret = getObject(arg0) === getObject(arg1);
418
+ const ret = arg0 === arg1;
481
419
  return ret;
482
420
  };
483
- imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
484
- const ret = BigInt.asUintN(64, arg0);
485
- return addHeapObject(ret);
421
+ imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
422
+ const ret = arg0 == arg1;
423
+ return ret;
486
424
  };
487
- imports.wbg.__wbg_eval_79d369b76bfbaa4a = function(arg0, arg1) {
488
- const ret = eval(getStringFromWasm0(arg0, arg1));
489
- return addHeapObject(ret);
425
+ imports.wbg.__wbindgen_memory = function() {
426
+ const ret = wasm.memory;
427
+ return ret;
428
+ };
429
+ imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
430
+ const obj = arg1;
431
+ const ret = typeof(obj) === 'number' ? obj : undefined;
432
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
433
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
434
+ };
435
+ imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
436
+ const obj = arg1;
437
+ const ret = typeof(obj) === 'string' ? obj : undefined;
438
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
439
+ var len1 = WASM_VECTOR_LEN;
440
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
441
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
442
+ };
443
+ imports.wbg.__wbindgen_throw = function(arg0, arg1) {
444
+ throw new Error(getStringFromWasm0(arg0, arg1));
490
445
  };
491
446
 
492
447
  return imports;
493
448
  }
494
449
 
495
- function __wbg_init_memory(imports, maybe_memory) {
450
+ function __wbg_init_memory(imports, memory) {
496
451
 
497
452
  }
498
453
 
499
454
  function __wbg_finalize_init(instance, module) {
500
455
  wasm = instance.exports;
501
456
  __wbg_init.__wbindgen_wasm_module = module;
502
- cachedBigInt64Memory0 = null;
503
- cachedFloat64Memory0 = null;
504
- cachedInt32Memory0 = null;
505
- cachedUint8Memory0 = null;
457
+ cachedDataViewMemory0 = null;
458
+ cachedUint8ArrayMemory0 = null;
506
459
 
507
460
 
461
+ wasm.__wbindgen_start();
508
462
  return wasm;
509
463
  }
510
464
 
511
465
  function initSync(module) {
512
466
  if (wasm !== undefined) return wasm;
513
467
 
468
+
469
+ if (typeof module !== 'undefined') {
470
+ if (Object.getPrototypeOf(module) === Object.prototype) {
471
+ ({module} = module)
472
+ } else {
473
+ console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
474
+ }
475
+ }
476
+
514
477
  const imports = __wbg_get_imports();
515
478
 
516
479
  __wbg_init_memory(imports);
@@ -524,24 +487,33 @@ function initSync(module) {
524
487
  return __wbg_finalize_init(instance, module);
525
488
  }
526
489
 
527
- async function __wbg_init(input) {
490
+ async function __wbg_init(module_or_path) {
528
491
  if (wasm !== undefined) return wasm;
529
492
 
530
- if (typeof input === 'undefined') {
531
- input = new URL('windmill_parser_wasm_bg.wasm', import.meta.url);
493
+
494
+ if (typeof module_or_path !== 'undefined') {
495
+ if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
496
+ ({module_or_path} = module_or_path)
497
+ } else {
498
+ console.warn('using deprecated parameters for the initialization function; pass a single object instead')
499
+ }
500
+ }
501
+
502
+ if (typeof module_or_path === 'undefined') {
503
+ module_or_path = new URL('windmill_parser_wasm_bg.wasm', import.meta.url);
532
504
  }
533
505
  const imports = __wbg_get_imports();
534
506
 
535
- if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
536
- input = fetch(input);
507
+ if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
508
+ module_or_path = fetch(module_or_path);
537
509
  }
538
510
 
539
511
  __wbg_init_memory(imports);
540
512
 
541
- const { instance, module } = await __wbg_load(await input, imports);
513
+ const { instance, module } = await __wbg_load(await module_or_path, imports);
542
514
 
543
515
  return __wbg_finalize_init(instance, module);
544
516
  }
545
517
 
546
- export { initSync }
518
+ export { initSync };
547
519
  export default __wbg_init;
Binary file