windmill-parser-wasm-ts 1.438.2 → 1.504.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.
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.504.0",
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,25 @@
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;
6
+ export function parse_assets_ts(code: string): string;
19
7
 
20
8
  export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
21
9
 
22
10
  export interface InitOutput {
23
11
  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;
12
+ readonly parse_deno: (a: number, b: number, c: number, d: number) => [number, number];
13
+ readonly parse_outputs: (a: number, b: number) => [number, number];
14
+ readonly parse_ts_imports: (a: number, b: number) => [number, number];
15
+ readonly parse_assets_ts: (a: number, b: number) => [number, number];
16
+ readonly __wbindgen_exn_store: (a: number) => void;
17
+ readonly __externref_table_alloc: () => number;
18
+ readonly __wbindgen_export_2: WebAssembly.Table;
27
19
  readonly __wbindgen_malloc: (a: number, b: number) => number;
28
20
  readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
29
- readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
30
21
  readonly __wbindgen_free: (a: number, b: number, c: number) => void;
31
- readonly __wbindgen_exn_store: (a: number) => void;
22
+ readonly __wbindgen_start: () => void;
32
23
  }
33
24
 
34
25
  export type SyncInitInput = BufferSource | WebAssembly.Module;
@@ -36,18 +27,18 @@ export type SyncInitInput = BufferSource | WebAssembly.Module;
36
27
  * Instantiates the given `module`, which can either be bytes or
37
28
  * a precompiled `WebAssembly.Module`.
38
29
  *
39
- * @param {SyncInitInput} module
30
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
40
31
  *
41
32
  * @returns {InitOutput}
42
33
  */
43
- export function initSync(module: SyncInitInput): InitOutput;
34
+ export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
44
35
 
45
36
  /**
46
37
  * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
47
38
  * for everything else, calls `WebAssembly.instantiate` directly.
48
39
  *
49
- * @param {InitInput | Promise<InitInput>} module_or_path
40
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
50
41
  *
51
42
  * @returns {Promise<InitOutput>}
52
43
  */
53
- export default function __wbg_init (module_or_path?: InitInput | Promise<InitInput>): Promise<InitOutput>;
44
+ 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;
40
+ let cachedDataViewMemory0 = null;
55
41
 
56
- function getFloat64Memory0() {
57
- if (cachedFloat64Memory0 === null || cachedFloat64Memory0.byteLength === 0) {
58
- cachedFloat64Memory0 = new Float64Array(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);
59
45
  }
60
- return cachedFloat64Memory0;
61
- }
62
-
63
- let cachedInt32Memory0 = null;
64
-
65
- function getInt32Memory0() {
66
- if (cachedInt32Memory0 === null || cachedInt32Memory0.byteLength === 0) {
67
- cachedInt32Memory0 = new Int32Array(wasm.memory.buffer);
68
- }
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,83 +110,138 @@ 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) {
229
+ /**
230
+ * @param {string} code
231
+ * @returns {string}
232
+ */
233
+ export function parse_assets_ts(code) {
234
+ let deferred2_0;
235
+ let deferred2_1;
274
236
  try {
275
- return f.apply(this, args);
276
- } catch (e) {
277
- wasm.__wbindgen_exn_store(addHeapObject(e));
237
+ const ptr0 = passStringToWasm0(code, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
238
+ const len0 = WASM_VECTOR_LEN;
239
+ const ret = wasm.parse_assets_ts(ptr0, len0);
240
+ deferred2_0 = ret[0];
241
+ deferred2_1 = ret[1];
242
+ return getStringFromWasm0(ret[0], ret[1]);
243
+ } finally {
244
+ wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
278
245
  }
279
246
  }
280
247
 
@@ -286,7 +253,7 @@ async function __wbg_load(module, imports) {
286
253
 
287
254
  } catch (e) {
288
255
  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);
256
+ 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
257
 
291
258
  } else {
292
259
  throw e;
@@ -312,205 +279,220 @@ async function __wbg_load(module, imports) {
312
279
  function __wbg_get_imports() {
313
280
  const imports = {};
314
281
  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;
282
+ imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
283
+ const ret = arg0.buffer;
321
284
  return ret;
322
285
  };
323
- imports.wbg.__wbindgen_is_object = function(arg0) {
324
- const val = getObject(arg0);
325
- const ret = typeof(val) === 'object' && val !== null;
286
+ imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
287
+ const ret = arg0.call(arg1);
326
288
  return ret;
327
- };
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';
334
- 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
289
  }, arguments) };
343
- imports.wbg.__wbg_done_298b57d23c0fc80c = function(arg0) {
344
- const ret = getObject(arg0).done;
290
+ imports.wbg.__wbg_done_769e5ede4b31c67b = function(arg0) {
291
+ const ret = arg0.done;
345
292
  return ret;
346
293
  };
347
- imports.wbg.__wbg_value_d93c65011f51a456 = function(arg0) {
348
- const ret = getObject(arg0).value;
349
- return addHeapObject(ret);
294
+ imports.wbg.__wbg_entries_3265d4158b33e5dc = function(arg0) {
295
+ const ret = Object.entries(arg0);
296
+ return ret;
350
297
  };
351
- imports.wbg.__wbg_iterator_2cee6dadfd956dfa = function() {
352
- const ret = Symbol.iterator;
353
- return addHeapObject(ret);
298
+ imports.wbg.__wbg_eval_907c7552de1a5dc7 = function(arg0, arg1) {
299
+ const ret = eval(getStringFromWasm0(arg0, arg1));
300
+ return ret;
354
301
  };
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);
302
+ imports.wbg.__wbg_get_67b2ba62fc30de12 = function() { return handleError(function (arg0, arg1) {
303
+ const ret = Reflect.get(arg0, arg1);
304
+ return ret;
362
305
  }, arguments) };
363
- imports.wbg.__wbg_isArray_2ab64d95e09ea0ae = function(arg0) {
364
- const ret = Array.isArray(getObject(arg0));
306
+ imports.wbg.__wbg_get_b9b93047fe3cf45b = function(arg0, arg1) {
307
+ const ret = arg0[arg1 >>> 0];
365
308
  return ret;
366
309
  };
367
- imports.wbg.__wbg_instanceof_ArrayBuffer_836825be07d4c9d2 = function(arg0) {
310
+ imports.wbg.__wbg_instanceof_ArrayBuffer_e14585432e3737fc = function(arg0) {
368
311
  let result;
369
312
  try {
370
- result = getObject(arg0) instanceof ArrayBuffer;
313
+ result = arg0 instanceof ArrayBuffer;
371
314
  } catch (_) {
372
315
  result = false;
373
316
  }
374
317
  const ret = result;
375
318
  return ret;
376
319
  };
377
- imports.wbg.__wbg_instanceof_Map_87917e0a7aaf4012 = function(arg0) {
320
+ imports.wbg.__wbg_instanceof_Map_f3469ce2244d2430 = function(arg0) {
378
321
  let result;
379
322
  try {
380
- result = getObject(arg0) instanceof Map;
323
+ result = arg0 instanceof Map;
381
324
  } catch (_) {
382
325
  result = false;
383
326
  }
384
327
  const ret = result;
385
328
  return ret;
386
329
  };
387
- imports.wbg.__wbg_isSafeInteger_f7b04ef02296c4d2 = function(arg0) {
388
- const ret = Number.isSafeInteger(getObject(arg0));
330
+ imports.wbg.__wbg_instanceof_Uint8Array_17156bcf118086a9 = function(arg0) {
331
+ let result;
332
+ try {
333
+ result = arg0 instanceof Uint8Array;
334
+ } catch (_) {
335
+ result = false;
336
+ }
337
+ const ret = result;
389
338
  return ret;
390
339
  };
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);
340
+ imports.wbg.__wbg_isArray_a1eab7e0d067391b = function(arg0) {
341
+ const ret = Array.isArray(arg0);
342
+ return ret;
398
343
  };
399
- imports.wbg.__wbg_buffer_12d079cc21e14bdb = function(arg0) {
400
- const ret = getObject(arg0).buffer;
401
- return addHeapObject(ret);
344
+ imports.wbg.__wbg_isSafeInteger_343e2beeeece1bb0 = function(arg0) {
345
+ const ret = Number.isSafeInteger(arg0);
346
+ return ret;
402
347
  };
403
- imports.wbg.__wbg_new_63b92bc8671ed464 = function(arg0) {
404
- const ret = new Uint8Array(getObject(arg0));
405
- return addHeapObject(ret);
348
+ imports.wbg.__wbg_iterator_9a24c88df860dc65 = function() {
349
+ const ret = Symbol.iterator;
350
+ return ret;
406
351
  };
407
- imports.wbg.__wbg_set_a47bac70306a19a7 = function(arg0, arg1, arg2) {
408
- getObject(arg0).set(getObject(arg1), arg2 >>> 0);
352
+ imports.wbg.__wbg_length_a446193dc22c12f8 = function(arg0) {
353
+ const ret = arg0.length;
354
+ return ret;
409
355
  };
410
- imports.wbg.__wbg_length_c20a40f15020d68a = function(arg0) {
411
- const ret = getObject(arg0).length;
356
+ imports.wbg.__wbg_length_e2d2a49132c1b256 = function(arg0) {
357
+ const ret = arg0.length;
412
358
  return ret;
413
359
  };
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;
360
+ imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
361
+ const ret = new Uint8Array(arg0);
422
362
  return ret;
423
363
  };
424
- imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
425
- const ret = new Error(getStringFromWasm0(arg0, arg1));
426
- return addHeapObject(ret);
364
+ imports.wbg.__wbg_next_25feadfc0913fea9 = function(arg0) {
365
+ const ret = arg0.next;
366
+ return ret;
427
367
  };
428
- imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
429
- const ret = getObject(arg0) == getObject(arg1);
368
+ imports.wbg.__wbg_next_6574e1a8a62d1055 = function() { return handleError(function (arg0) {
369
+ const ret = arg0.next();
430
370
  return ret;
371
+ }, arguments) };
372
+ imports.wbg.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
373
+ arg0.set(arg1, arg2 >>> 0);
431
374
  };
432
- imports.wbg.__wbindgen_boolean_get = function(arg0) {
433
- const v = getObject(arg0);
434
- const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
375
+ imports.wbg.__wbg_value_cd1ffa7b1ab794f1 = function(arg0) {
376
+ const ret = arg0.value;
435
377
  return ret;
436
378
  };
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);
379
+ imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
380
+ const ret = arg0;
381
+ return ret;
442
382
  };
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;
383
+ imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
384
+ const ret = BigInt.asUintN(64, arg0);
385
+ return ret;
450
386
  };
451
387
  imports.wbg.__wbindgen_bigint_get_as_i64 = function(arg0, arg1) {
452
- const v = getObject(arg1);
388
+ const v = arg1;
453
389
  const ret = typeof(v) === 'bigint' ? v : undefined;
454
- getBigInt64Memory0()[arg0 / 8 + 1] = isLikeNone(ret) ? BigInt(0) : ret;
455
- getInt32Memory0()[arg0 / 4 + 0] = !isLikeNone(ret);
390
+ getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
391
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
392
+ };
393
+ imports.wbg.__wbindgen_boolean_get = function(arg0) {
394
+ const v = arg0;
395
+ const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
396
+ return ret;
456
397
  };
457
398
  imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
458
- const ret = debugString(getObject(arg1));
399
+ const ret = debugString(arg1);
459
400
  const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
460
401
  const len1 = WASM_VECTOR_LEN;
461
- getInt32Memory0()[arg0 / 4 + 1] = len1;
462
- getInt32Memory0()[arg0 / 4 + 0] = ptr1;
402
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
403
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
463
404
  };
464
- imports.wbg.__wbindgen_throw = function(arg0, arg1) {
465
- throw new Error(getStringFromWasm0(arg0, arg1));
405
+ imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
406
+ const ret = new Error(getStringFromWasm0(arg0, arg1));
407
+ return ret;
408
+ };
409
+ imports.wbg.__wbindgen_in = function(arg0, arg1) {
410
+ const ret = arg0 in arg1;
411
+ return ret;
412
+ };
413
+ imports.wbg.__wbindgen_init_externref_table = function() {
414
+ const table = wasm.__wbindgen_export_2;
415
+ const offset = table.grow(4);
416
+ table.set(0, undefined);
417
+ table.set(offset + 0, undefined);
418
+ table.set(offset + 1, null);
419
+ table.set(offset + 2, true);
420
+ table.set(offset + 3, false);
421
+ ;
466
422
  };
467
423
  imports.wbg.__wbindgen_is_bigint = function(arg0) {
468
- const ret = typeof(getObject(arg0)) === 'bigint';
424
+ const ret = typeof(arg0) === 'bigint';
469
425
  return ret;
470
426
  };
471
- imports.wbg.__wbindgen_in = function(arg0, arg1) {
472
- const ret = getObject(arg0) in getObject(arg1);
427
+ imports.wbg.__wbindgen_is_function = function(arg0) {
428
+ const ret = typeof(arg0) === 'function';
473
429
  return ret;
474
430
  };
475
- imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
476
- const ret = arg0;
477
- return addHeapObject(ret);
431
+ imports.wbg.__wbindgen_is_object = function(arg0) {
432
+ const val = arg0;
433
+ const ret = typeof(val) === 'object' && val !== null;
434
+ return ret;
478
435
  };
479
436
  imports.wbg.__wbindgen_jsval_eq = function(arg0, arg1) {
480
- const ret = getObject(arg0) === getObject(arg1);
437
+ const ret = arg0 === arg1;
481
438
  return ret;
482
439
  };
483
- imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
484
- const ret = BigInt.asUintN(64, arg0);
485
- return addHeapObject(ret);
440
+ imports.wbg.__wbindgen_jsval_loose_eq = function(arg0, arg1) {
441
+ const ret = arg0 == arg1;
442
+ return ret;
486
443
  };
487
- imports.wbg.__wbg_eval_79d369b76bfbaa4a = function(arg0, arg1) {
488
- const ret = eval(getStringFromWasm0(arg0, arg1));
489
- return addHeapObject(ret);
444
+ imports.wbg.__wbindgen_memory = function() {
445
+ const ret = wasm.memory;
446
+ return ret;
447
+ };
448
+ imports.wbg.__wbindgen_number_get = function(arg0, arg1) {
449
+ const obj = arg1;
450
+ const ret = typeof(obj) === 'number' ? obj : undefined;
451
+ getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
452
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
453
+ };
454
+ imports.wbg.__wbindgen_string_get = function(arg0, arg1) {
455
+ const obj = arg1;
456
+ const ret = typeof(obj) === 'string' ? obj : undefined;
457
+ var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
458
+ var len1 = WASM_VECTOR_LEN;
459
+ getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
460
+ getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
461
+ };
462
+ imports.wbg.__wbindgen_throw = function(arg0, arg1) {
463
+ throw new Error(getStringFromWasm0(arg0, arg1));
490
464
  };
491
465
 
492
466
  return imports;
493
467
  }
494
468
 
495
- function __wbg_init_memory(imports, maybe_memory) {
469
+ function __wbg_init_memory(imports, memory) {
496
470
 
497
471
  }
498
472
 
499
473
  function __wbg_finalize_init(instance, module) {
500
474
  wasm = instance.exports;
501
475
  __wbg_init.__wbindgen_wasm_module = module;
502
- cachedBigInt64Memory0 = null;
503
- cachedFloat64Memory0 = null;
504
- cachedInt32Memory0 = null;
505
- cachedUint8Memory0 = null;
476
+ cachedDataViewMemory0 = null;
477
+ cachedUint8ArrayMemory0 = null;
506
478
 
507
479
 
480
+ wasm.__wbindgen_start();
508
481
  return wasm;
509
482
  }
510
483
 
511
484
  function initSync(module) {
512
485
  if (wasm !== undefined) return wasm;
513
486
 
487
+
488
+ if (typeof module !== 'undefined') {
489
+ if (Object.getPrototypeOf(module) === Object.prototype) {
490
+ ({module} = module)
491
+ } else {
492
+ console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
493
+ }
494
+ }
495
+
514
496
  const imports = __wbg_get_imports();
515
497
 
516
498
  __wbg_init_memory(imports);
@@ -524,24 +506,33 @@ function initSync(module) {
524
506
  return __wbg_finalize_init(instance, module);
525
507
  }
526
508
 
527
- async function __wbg_init(input) {
509
+ async function __wbg_init(module_or_path) {
528
510
  if (wasm !== undefined) return wasm;
529
511
 
530
- if (typeof input === 'undefined') {
531
- input = new URL('windmill_parser_wasm_bg.wasm', import.meta.url);
512
+
513
+ if (typeof module_or_path !== 'undefined') {
514
+ if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
515
+ ({module_or_path} = module_or_path)
516
+ } else {
517
+ console.warn('using deprecated parameters for the initialization function; pass a single object instead')
518
+ }
519
+ }
520
+
521
+ if (typeof module_or_path === 'undefined') {
522
+ module_or_path = new URL('windmill_parser_wasm_bg.wasm', import.meta.url);
532
523
  }
533
524
  const imports = __wbg_get_imports();
534
525
 
535
- if (typeof input === 'string' || (typeof Request === 'function' && input instanceof Request) || (typeof URL === 'function' && input instanceof URL)) {
536
- input = fetch(input);
526
+ if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
527
+ module_or_path = fetch(module_or_path);
537
528
  }
538
529
 
539
530
  __wbg_init_memory(imports);
540
531
 
541
- const { instance, module } = await __wbg_load(await input, imports);
532
+ const { instance, module } = await __wbg_load(await module_or_path, imports);
542
533
 
543
534
  return __wbg_finalize_init(instance, module);
544
535
  }
545
536
 
546
- export { initSync }
537
+ export { initSync };
547
538
  export default __wbg_init;
Binary file